text,length,is_long_context,metric_val,label_metric
"//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include ""LoadedNetwork.hpp""
#include ""Layer.hpp""
#include ""Graph.hpp""
#include <Processes.hpp>
#include ""Profiling.hpp""
#include ""HeapProfiling.hpp""
#include ""WorkingMemHandle.hpp""

#include <armnn/BackendRegistry.hpp>
#include <armnn/Logging.hpp>
#include <armnn/utility/Assert.hpp>

#include <backendsCommon/TensorHandle.hpp>
#include <armnn/backends/IMemoryManager.hpp>
#include <backendsCommon/MemCopyWorkload.hpp>
#include <backendsCommon/MemSyncWorkload.hpp>
#include <armnn/BackendHelper.hpp>

#include <fmt/format.h>

namespace armnn
{

using namespace std;
using namespace armnn::profiling;

namespace
{

template <typename ExceptionType>
std::string ToErrorMessage(const char * prefix, const ExceptionType & error)
{
    std::stringstream ss;
    ss << prefix << "" "" << error.what();
    return ss.str();
}

void AddLayerStructure(std::unique_ptr<TimelineUtilityMethods>& timelineUtils,
                       const Layer& layer,
                       ProfilingGuid networkGuid)
{
    // Add layer to the post-optimisation network structure
    std::string layerName = layer.GetNameStr().empty() ? ""<Unnamed>"" : layer.GetNameStr();
    timelineUtils->CreateNamedTypedChildEntity(layer.GetGuid(),
                                               networkGuid,
                                               layerName,
                                               LabelsAndEventClasses::LAYER_GUID);
    for (auto&& input : layer.GetInputSlots())
    {
        const IOutputSlot* source = input.GetConnectedOutputSlot();
        ARMNN_ASSERT(source != NULL);
        timelineUtils->CreateConnectionRelationship(ProfilingRelationshipType::RetentionLink,
                                                    source->GetOwningLayerGuid(),
                                                    layer.GetGuid());
    }
}

void AddWorkloadStructure(std::unique_ptr<TimelineUtilityMethods>& timelineUtils,
                          std::unique_ptr<IWorkload>& workload,
                          const Layer& layer)
{
    // Add workload to the post-optimisation network structure
    timelineUtils->CreateTypedEntity(workload->GetGuid(), LabelsAndEventClasses::WORKLOAD_GUID);
    timelineUtils->MarkEntityWithLabel(workload->GetGuid(),
                                       layer.GetBackendId().Get(),
                                       LabelsAndEventClasses::BACKENDID_GUID);

    // Link the workload to the layer
    timelineUtils->CreateRelationship(ProfilingRelationshipType::RetentionLink,
                                      layer.GetGuid(),
                                      workload->GetGuid(),
                                      LabelsAndEventClasses::CHILD_GUID);
}

} // anonymous

std::unique_ptr<LoadedNetwork> LoadedNetwork::MakeLoadedNetwork(std::unique_ptr<IOptimizedNetwork> net,
                                                                std::string& errorMessage,
                                                                const INetworkProperties& networkProperties,
                                                                profiling::ProfilingService&  profilingService)
{
    std::unique_ptr<LoadedNetwork> loadedNetwork;

    auto Fail = [&](const std::exception& error) -> std::unique_ptr<LoadedNetwork>
    {
        errorMessage = ToErrorMessage(""An error occurred when preparing the network workloads: "", error);
        ARMNN_LOG(error) << errorMessage;

        return std::unique_ptr<LoadedNetwork>();
    };

    try
    {
        loadedNetwork.reset(new LoadedNetwork(std::move(net), networkProperties, profilingService));
    }
    catch (const armnn::RuntimeException& error)
    {
        return Fail(error);
    }
    catch (const armnn::Exception& error)
    {
        return Fail(error);
    }
    catch (const std::runtime_error& error)
    {
        return Fail(error);
    }

    return loadedNetwork;
}

LoadedNetwork::LoadedNetwork(std::unique_ptr<IOptimizedNetwork> net,
                             const INetworkProperties& networkProperties,
                             profiling::ProfilingService&  profilingService) :
                             m_OptimizedNetwork(std::move(net)),
                             m_NetworkProperties(networkProperties),
                             m_TensorHandleFactoryRegistry(),
                             m_ProfilingService(profilingService)
{
    ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""LoadedNetwork"");
    // Get the profiler and register it for the current thread.
    const std::shared_ptr<IProfiler>& profiler = m_OptimizedNetwork->GetProfiler();
    ProfilerManager::GetInstance().RegisterProfiler(profiler.get());

    profiler->EnableProfiling(networkProperties.m_ProfilingEnabled);

    profiler->EnableNetworkDetailsToStdOut(networkProperties.m_OutputNetworkDetailsMethod);

    //First create tensor handlers, backends and workload factories.
    //Handlers are created before workloads are.
    //Because workload creation can modify some of the handlers,
    //(for example the splitter and concat layers).

    bool useExternalMemoryManager = false;
    bool useInternalMemoryManager = false;
    Graph& order = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().TopologicalSort();
    for (auto&& layer : order)
    {
        auto const& backendId = layer->GetBackendId();
        if (m_Backends.count(backendId) == 0)
        {
            auto createBackend = BackendRegistryInstance().GetFactory(backendId);
            auto it = m_Backends.emplace(std::make_pair(backendId, createBackend()));

            IBackendInternal* backend = it.first->second.get();

            if (networkProperties.m_AsyncEnabled &&
                !HasCapability(BackendOptions::BackendOption{""AsyncExecution"", true}, backend->GetCapabilities()))
            {
                std::string er = backend->GetId();
                er += "" does not support AsyncExecution"";
                throw BackendCapabilityException(er);
            }

            if (networkProperties.m_AsyncEnabled &&
                !HasCapability(BackendOptions::BackendOption{""ExternallyManagedMemory"", true},
                backend->GetCapabilities()))
            {
                std::string er = backend->GetId();
                er += "" does not support ExternallyManagedMemory\\n"";
                er += ""AsyncEnabled networks require all backends to support ExternallyManagedMemory"";
                throw BackendCapabilityException(er);
            }

            if (HasCapability(BackendOptions::BackendOption{""ExternallyManagedMemory"", true},backend->GetCapabilities())
                && (m_NetworkProperties.m_ExternalMemoryManagementEnabled ||  m_NetworkProperties.m_AsyncEnabled))
            {
                m_SupportsExternallyManagedMemory[backend->GetId()] = true;
                useExternalMemoryManager = true;
            }
            else
            {
                m_SupportsExternallyManagedMemory[backend->GetId()] = false;
                useInternalMemoryManager = true;
            }

            IBackendInternal::IWorkloadFactoryPtr workloadFactory;
            if (backend->SupportsTensorAllocatorAPI())
            {
                workloadFactory = backend->CreateWorkloadFactory(
                    m_TensorHandleFactoryRegistry,
                    m_OptimizedNetwork->pOptimizedNetworkImpl->GetModelOptions(),
                    static_cast<MemorySourceFlags>(m_NetworkProperties.m_InputSource),
                    static_cast<MemorySourceFlags>(m_NetworkProperties.m_OutputSource));
            }
            else
            {
                m_BackendMemoryMangers.emplace_back(backend->CreateMemoryManager());
                workloadFactory = backend->CreateWorkloadFactory(
                        m_BackendMemoryMangers.back(), m_OptimizedNetwork->pOptimizedNetworkImpl->GetModelOptions());
            }
            m_WorkloadFactories[backendId ] = std::move(workloadFactory);
        }
    }

    if (!networkProperties.m_AsyncEnabled)
    {
        for (auto&& layer : order)
        {
            auto& workloadFactory = GetWorkloadFactory(*layer);
            bool supportsExternalManager = m_SupportsExternallyManagedMemory[layer->GetBackendId()];

            switch (layer->GetType())
            {
                case LayerType::Input:
                case LayerType::MemImport:
                {
                    // If IsImportEnabled is true then we need to set IsMemoryManaged
                    // to false when creating TensorHandles
                    layer->CreateTensorHandles(m_TensorHandleFactoryRegistry,
                                               workloadFactory,
                                               !supportsExternalManager && !m_NetworkProperties.m_ImportEnabled);
                    break;
                }
                case LayerType::Constant:
                {
                    layer->CreateTensorHandles(m_TensorHandleFactoryRegistry, workloadFactory, true);
                    break;
                }
                default:
                {
                    // Look for a layer with 1 OutputSlot which has 1 connection and that connection is an Output Layer
                    // If Export is enabled disable memory management so we can export, otherwise we do a copy
                    if ((layer->GetNumOutputSlots() == 1) &&
                       (layer->GetOutputSlots()[0].GetNumConnections() == 1) &&
                       (layer->GetOutputSlots()[0].GetConnection(0)->GetOwningLayer().GetType() == LayerType::Output))
                    {
                        layer->CreateTensorHandles(m_TensorHandleFactoryRegistry,
                                                   workloadFactory,
                                                   !supportsExternalManager && !m_NetworkProperties.m_ExportEnabled);
                    }
                    else
                    {
                        layer->CreateTensorHandles(m_TensorHandleFactoryRegistry,
                                                   workloadFactory,
                                                   !supportsExternalManager);
                    }
                }
            }
        }
    }

    ProfilingGuid networkGuid = m_OptimizedNetwork->GetGuid();
    std::unique_ptr<TimelineUtilityMethods> timelineUtils =
                        TimelineUtilityMethods::GetTimelineUtils(m_ProfilingService);
    if (timelineUtils)
    {
        timelineUtils->CreateTypedEntity(networkGuid, LabelsAndEventClasses::NETWORK_GUID);
        // Mark the network with a start of life event
        timelineUtils->RecordEvent(networkGuid, LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
        // and with the process ID
        int processID = armnnUtils::Processes::GetCurrentId();
        std::stringstream ss;
        ss << processID;
        timelineUtils->MarkEntityWithLabel(networkGuid, ss.str(), LabelsAndEventClasses::PROCESS_ID_GUID);
    }

    //Then create workloads.
    {
        ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""LoadNetwork_CreateWorkloads"");
        for (auto&& layer: order)
        {
            if (timelineUtils)
            {
                // Add layer to the post-optimisation network structure
                AddLayerStructure(timelineUtils, *layer, networkGuid);
            }

            const IWorkloadFactory& workloadFactory = GetWorkloadFactory(*layer);

            switch (layer->GetType())
            {
                case LayerType::Input:
                case LayerType::Output:
                {
                    // Inputs and outputs are treated in a special way - see EnqueueInput() and EnqueueOutput().
                    break;
                }
                default:
                {
                    auto workload = layer->CreateWorkload(workloadFactory);

                    if (!workload)
                    {
                        const char* const layerName =
                                layer->GetNameStr().length() != 0 ? layer->GetName() : ""<Unnamed>"";
                        throw InvalidArgumentException(
                                fmt::format(""No workload created for layer (name: '{0}' type: '{1}') (compute '{2}')"",
                                            layerName, static_cast<int>(layer->GetType()), layer->GetBackendId().Get()
                                ));
                    }

                    if (timelineUtils)
                    {
                        // Add workload to the post-optimisation network structure
                        AddWorkloadStructure(timelineUtils, workload, *layer);
                    }

                    // For async networks ConstantWorkloads are managed exclusively by LoadedNetwork
                    // and are separated out from the other workloads
                    if((networkProperties.m_AsyncEnabled  || useExternalMemoryManager) &&
                        layer->GetType() == LayerType::Constant)
                    {
                        m_ConstantTensorHandles[layer->GetGuid()] =
                                layer->GetOutputSlot(0).GetOutputHandler().GetData();
                        m_ConstantWorkloads[layer->GetGuid()] = std::move(workload);
                    }
                    else
                    {
                        m_WorkloadQueue.push_back(std::move(workload));
                    }

                    // release the constant data in the layer..
                    layer->ReleaseConstantData();
                    break;
                }
            }
        }
    }

    for (auto&& workloadFactory : m_WorkloadFactories)
    {
        workloadFactory.second->AfterWorkloadsCreated();
    }

    if (timelineUtils)
    {
        // Commit to send the post-optimisation network structure
        timelineUtils->Commit();
    }

    if (useExternalMemoryManager)
    {
        if (networkProperties.m_AsyncEnabled)
        {
            CreateMemoryProfileAsync();
        }
        else
        {
            CreateMemoryProfile();
        }

        auto backendStrategyMap = BackendRegistryInstance().GetMemoryOptimizerStrategies();
        for (auto& backendMemoryProfile : m_MemBlockMap)
        {
            const BackendId& backendId = backendMemoryProfile.first;
            if (backendStrategyMap.find(backendId) != backendStrategyMap.end())
            {
                m_MemBinMap[backendId] = backendStrategyMap[backendId]->Optimize(backendMemoryProfile.second);
            }
            else
            {
                m_MemBinMap[backendId] = m_ConstantStrategy->Optimize(backendMemoryProfile.second);
            }
        }

        if (!networkProperties.m_AsyncEnabled)
        {
            m_ExternalMemoryManager = CreateExternalMemoryManger(m_TensorMemory);

            // Sort m_TensorMemory, so it's order matches m_Tensorhandles
            std::sort(m_TensorMemory.begin(), m_TensorMemory.end(),
                      [](const std::pair<std::shared_ptr<TensorMemory>, MemorySource>& lhs,
                         const std::pair<std::shared_ptr<TensorMemory>, MemorySource>& rhs)
                      {
                          return lhs.first->m_OutputSlotId < rhs.first->m_OutputSlotId;
                      });
        }
    }

    // Now that the intermediate tensor memory has been set-up,
    // do any post allocation configuration for each workload.
    if (!networkProperties.m_AsyncEnabled)
    {
        if (useInternalMemoryManager)
        {
            // Set up memory.
            m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().AllocateDynamicBuffers();
        }

        for (auto &workload : m_WorkloadQueue)
        {
            workload->PostAllocationConfigure();
        }
    }

    if (useExternalMemoryManager)
    {
        if (!networkProperties.m_AsyncEnabled)
        {
            AllocateAndExecuteConstantWorkloads();
        }
        else
        {
            AllocateAndExecuteConstantWorkloadsAsync();
        }
    }
}

void LoadedNetwork::AllocateAndExecuteConstantWorkloads()
{
    ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""LoadNetwork_AllocateAndExecuteConstants"");
    for (auto& pair : m_ConstantWorkloads)
    {
        auto tensorHandle = m_ConstantTensorHandles[pair.first];
        tensorHandle->Allocate();
        pair.second->Execute();
    }
}



void LoadedNetwork::AllocateAndExecuteConstantWorkloadsAsync()
{
    ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""LoadNetwork_AllocateAndExecuteConstants"");
    Graph& order = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph();
    for (auto&& layer : order)
    {
        if (layer->GetType() == LayerType::Constant)
        {
            const auto& outSlot = layer->GetOutputSlots()[0];
            const auto factoryId = outSlot.GetTensorHandleFactoryId();
            ARMNN_ASSERT(factoryId != ITensorHandleFactory::LegacyFactoryId);
            auto& workloadFactory = GetWorkloadFactory(*layer);

            layer->CreateTensorHandles(m_TensorHandleFactoryRegistry, workloadFactory);
            ITensorHandle* tensorHandle = outSlot.GetOutputHandler().GetData();

            m_ConstantTensorHandles[layer->GetGuid()] = tensorHandle;
            tensorHandle->Allocate();

            WorkingMemDescriptor memDesc;
            memDesc.m_Outputs.push_back(tensorHandle);
            m_ConstantWorkloads[layer->GetGuid()]->ExecuteAsync(memDesc);
        }
    }
}

void LoadedNetwork::SendNetworkStructure()
{
    ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""LoadNetwork_SendNetworkStructure"");
    Graph& order = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().TopologicalSort();
    ProfilingGuid networkGuid = m_OptimizedNetwork->GetGuid();

    std::unique_ptr<TimelineUtilityMethods> timelineUtils =
                        TimelineUtilityMethods::GetTimelineUtils(m_ProfilingService);

    timelineUtils->CreateTypedEntity(networkGuid, LabelsAndEventClasses::NETWORK_GUID);

    for (auto&& layer : order)
    {
        // Add layer to the post-optimisation network structure
        AddLayerStructure(timelineUtils, *layer, networkGuid);
        switch (layer->GetType())
        {
        case LayerType::Input:
        case LayerType::Output:
        {
            // Inputs and outputs are treated in a special way - see EnqueueInput() and EnqueueOutput().
            break;
        }
        default:
            {
            for (auto& workload : m_WorkloadQueue)
            {
                // Add workload to the post-optimisation network structure
                AddWorkloadStructure(timelineUtils, workload, *layer);
            }
            break;
            }
        }
    }
    // Commit to send the post-optimisation network structure
    timelineUtils->Commit();
}

profiling::ProfilingGuid LoadedNetwork::GetNetworkGuid()
{
    return m_OptimizedNetwork->GetGuid();
}

TensorInfo LoadedNetwork::GetInputTensorInfo(LayerBindingId layerId) const
{
    for (auto&& inputLayer : m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().GetInputLayers())
    {
        ARMNN_ASSERT_MSG(inputLayer->GetNumOutputSlots() == 1, ""Input layer should have exactly 1 output slot"");
        if (inputLayer->GetBindingId() == layerId)
        {
            return inputLayer->GetOutputSlot(0).GetTensorInfo();
        }
    }

    throw InvalidArgumentException(fmt::format(""No input layer is associated with id {}"", layerId));
}

TensorInfo LoadedNetwork::GetOutputTensorInfo(LayerBindingId layerId) const
{
    for (auto&& outputLayer : m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().GetOutputLayers())
    {
        ARMNN_ASSERT_MSG(outputLayer->GetNumInputSlots() == 1, ""Output layer should have exactly 1 input slot"");
        ARMNN_ASSERT_MSG(outputLayer->GetInputSlot(0).GetConnection(), ""Input slot on Output layer must be connected"");
        if (outputLayer->GetBindingId() == layerId)
        {
            return outputLayer->GetInputSlot(0).GetConnection()->GetTensorInfo();
        }
    }

    throw InvalidArgumentException(fmt::format(""No output layer is associated with id {}"", layerId));
}

const IWorkloadFactory& LoadedNetwork::GetWorkloadFactory(const Layer& layer) const
{
    const IWorkloadFactory* workloadFactory = nullptr;

    auto it = m_WorkloadFactories.find(layer.GetBackendId());
    if (it ==  m_WorkloadFactories.end())
    {
        throw RuntimeException(fmt::format(""No workload factory for {0} to be used for layer: {1}"",
                                           layer.GetBackendId().Get(),
                                           layer.GetNameStr()),
                                           CHECK_LOCATION());
    }

    workloadFactory = it->second.get();

    ARMNN_ASSERT_MSG(workloadFactory, ""No workload factory"");

    std::string reasonIfUnsupported;
    ARMNN_ASSERT_MSG(IWorkloadFactory::IsLayerSupported(layer,
                                                        {},
                                                        reasonIfUnsupported,
                                                        m_OptimizedNetwork->pOptimizedNetworkImpl->GetModelOptions()),
        ""Factory does not support layer"");
    IgnoreUnused(reasonIfUnsupported);
    return *workloadFactory;
}

namespace {

// Non-copyable class owning accelerator-specific tensor data.
class TensorPin
{
public:
    TensorPin(std::unique_ptr<ITensorHandle> handle, const TensorInfo& info, LayerBindingId id)
        : m_TensorHandle(std::move(handle))
        , m_TensorInfo(info)
        , m_Id(id)
    {
    }

    ITensorHandle* GetTensorHandle() const { return m_TensorHandle.get(); }
    const TensorInfo& GetTensorInfo() const { return m_TensorInfo; }
    LayerBindingId GetBindingId() const { return m_Id; }

private:
    std::unique_ptr<ITensorHandle> m_TensorHandle;
    TensorInfo m_TensorInfo;
    LayerBindingId m_Id;
};

static const TensorPin& GetTensorPin(LayerBindingId id,
    const std::vector<TensorPin>& pins,
    char const* bindingPointDesc)
{
    auto it = std::find_if(pins.begin(), pins.end(),
        [id](const TensorPin& pin)
    {
        return pin.GetBindingId() == id;
    });

    if (it != pins.end())
    {
        return *it;
    }
    else
    {
        throw InvalidArgumentException(fmt::format(""No tensor supplied for {0} {1}"", bindingPointDesc, id));
    }
}

// Stores data that needs to be kept accessible for the entire execution of a workload.
class WorkloadData
{
public:
    WorkloadData(const InputTensors& inputTensors, const OutputTensors& outputTensors)
    {
        m_InputTensorPins.reserve(inputTensors.size());
        m_OutputTensorPins.reserve(outputTensors.size());

        for (auto inputTensorPair : inputTensors)
        {
            auto inputTensor = inputTensorPair.second;

            std::unique_ptr<ITensorHandle> tensorHandle =
                std::make_unique<ConstPassthroughTensorHandle>(inputTensor.GetInfo(),inputTensor.GetMemoryArea());
            LayerBindingId layerId = inputTensorPair.first;

            m_InputTensorPins.emplace_back(std::move(tensorHandle), inputTensor.GetInfo(), layerId);
        }

        for (auto outputTensorPair : outputTensors)
        {
            auto outputTensor = outputTensorPair.second;

            std::unique_ptr<ITensorHandle> tensorHandle =
                std::make_unique<PassthroughTensorHandle>(outputTensor.GetInfo(), outputTensor.GetMemoryArea());
            LayerBindingId layerId = outputTensorPair.first;

            m_OutputTensorPins.emplace_back(std::move(tensorHandle), outputTensor.GetInfo(), layerId);
        }
    }

    const TensorPin& GetInputTensorPin(LayerBindingId id) const
    {
        return GetTensorPin(id, m_InputTensorPins, ""input"");
    }

    const TensorPin& GetOutputTensorPin(LayerBindingId id) const
    {
        return GetTensorPin(id, m_OutputTensorPins, ""output"");
    }

private:

    std::vector<TensorPin> m_InputTensorPins;
    std::vector<TensorPin> m_OutputTensorPins;
};

}

Status LoadedNetwork::EnqueueWorkload(const InputTensors& inputTensors,
                                      const OutputTensors& outputTensors)
{
    const Graph& graph = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph();

    // Walk graph to determine the order of execution.
    if (graph.GetNumLayers() < 2)
    {
        ARMNN_LOG(warning) << ""IRuntime::EnqueueWorkload()::Less than two nodes in graph"";
        return Status::Failure;
    }

    // Data that must be kept alive for the entire execution of the workload.
    WorkloadData workloadData(inputTensors, outputTensors);

    if (graph.GetNumInputs() != inputTensors.size())
    {
        throw InvalidArgumentException(""Number of inputs provided does not match network."");
    }

    // For each input to the network, call EnqueueInput with the data passed by the user.
    {
        ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""PrepareInputs"");
        m_InputQueue.clear();
        m_InputQueue.reserve(graph.GetNumInputs());
        for (const BindableLayer* inputLayer : graph.GetInputLayers())
        {
            const TensorPin& pin = workloadData.GetInputTensorPin(inputLayer->GetBindingId());
            EnqueueInput(*inputLayer, pin.GetTensorHandle(), pin.GetTensorInfo());
        }
    }

    // For each output to the network, call EnqueueOutput with the data passed by the user.
    {
        ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""PrepareOutputs"");
        m_OutputQueue.clear();
        m_OutputQueue.reserve(graph.GetNumOutputs());
        for (const BindableLayer* outputLayer : graph.GetOutputLayers())
        {
            const TensorPin& pin = workloadData.GetOutputTensorPin(outputLayer->GetBindingId());
            EnqueueOutput(*outputLayer, pin.GetTensorHandle(), pin.GetTensorInfo());
        }
    }

    std::unique_ptr<TimelineUtilityMethods> timelineUtils =
                        TimelineUtilityMethods::GetTimelineUtils(m_ProfilingService);
    ProfilingGuid inferenceGuid = m_ProfilingService.GetNextGuid();
    if (timelineUtils)
    {
        // Add inference timeline trace if profiling is enabled.
        ProfilingGuid networkGuid = m_OptimizedNetwork->GetGuid();
        timelineUtils->CreateTypedEntity(inferenceGuid, LabelsAndEventClasses::INFERENCE_GUID);
        timelineUtils->CreateRelationship(ProfilingRelationshipType::RetentionLink,
                                          networkGuid,
                                          inferenceGuid,
                                          LabelsAndEventClasses::EXECUTION_OF_GUID);
        timelineUtils->RecordEvent(inferenceGuid, LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
    }

    bool executionSucceeded = true;

    {
        if (m_ProfilingService.IsProfilingEnabled())
        {
            m_ProfilingService.IncrementCounterValue(armnn::profiling::INFERENCES_RUN);
        }
        ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""Execute"");
        ARMNN_SCOPED_HEAP_PROFILING(""Executing"");
        executionSucceeded = Execute(timelineUtils, inferenceGuid);
    }

    if (timelineUtils)
    {
        // Add end of life of the inference timeline if profiling is enabled.
        timelineUtils->RecordEvent(inferenceGuid, LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
        timelineUtils->Commit();
    }
    return executionSucceeded ? Status::Success : Status::Failure;
}

void LoadedNetwork::EnqueueInput(const BindableLayer& layer, ITensorHandle* tensorHandle, const TensorInfo& tensorInfo)
{
    if (layer.GetType() != LayerType::Input)
    {
        throw InvalidArgumentException(""EnqueueInput: given layer not an InputLayer"");
    }

    if (tensorHandle == nullptr)
    {
        throw InvalidArgumentException(""EnqueueInput: tensorHandle must not be NULL"");
    }

    InputQueueDescriptor inputQueueDescriptor;
    WorkloadInfo info;

    inputQueueDescriptor.m_Inputs.push_back(tensorHandle);
    info.m_InputTensorInfos.push_back(tensorInfo);

    ARMNN_ASSERT_MSG(layer.GetNumOutputSlots() == 1, ""Can only handle Input Layer with one output"");
    const OutputHandler& handler = layer.GetOutputHandler();
    const TensorInfo& outputTensorInfo = handler.GetTensorInfo();
    ITensorHandle* outputTensorHandle = handler.GetData();
    ARMNN_ASSERT_MSG(outputTensorHandle != nullptr,
                     ""Data should have been allocated."");
    inputQueueDescriptor.m_Outputs.push_back(outputTensorHandle);
    info.m_OutputTensorInfos.push_back(outputTensorInfo);

    MemorySourceFlags importFlags = outputTensorHandle->GetImportFlags();
    bool needMemCopy = true;
    if (m_NetworkProperties.m_ImportEnabled)  // Try import the input tensor
    {
        if(CheckFlag(importFlags, m_NetworkProperties.m_InputSource))
        {
            needMemCopy = false;
            // This assumes a CPU Tensor handle
            void* mem = tensorHandle->Map(false);
            if (outputTensorHandle->Import(mem, m_NetworkProperties.m_InputSource))
            {
                tensorHandle->Unmap();
                return; // No need for a workload since the import has been done.
            }
            tensorHandle->Unmap();
            throw MemoryImportException(""EnqueueInput: Memory Import failed"");
        }
    }
    if (needMemCopy)
    {
        // Create a mem copy workload for input since we did not import
        std::unique_ptr<IWorkload> inputWorkload = std::make_unique<CopyMemGenericWorkload>(inputQueueDescriptor, info);

        ARMNN_ASSERT_MSG(inputWorkload, ""No input workload created"");

        std::unique_ptr<TimelineUtilityMethods> timelineUtils =
                            TimelineUtilityMethods::GetTimelineUtils(m_ProfilingService);
        if (timelineUtils)
        {
            // Add Input Workload to the post-optimisation network structure
            AddWorkloadStructure(timelineUtils, inputWorkload, layer);
            timelineUtils->Commit();
        }

        m_InputQueue.push_back(move(inputWorkload));
    }
}

void LoadedNetwork::EnqueueOutput(const BindableLayer& layer, ITensorHandle* tensorHandle, const TensorInfo& tensorInfo)
{
    if (layer.GetType() != LayerType::Output)
    {
        throw InvalidArgumentException(""EnqueueOutput: given layer not an OutputLayer"");
    }

    if (tensorHandle == nullptr)
    {
        throw InvalidArgumentException(""EnqueueOutput: tensorHandle must not be NULL"");
    }

    OutputQueueDescriptor outputQueueDescriptor;
    WorkloadInfo info;

    outputQueueDescriptor.m_Outputs.push_back(tensorHandle);
    info.m_OutputTensorInfos.push_back(tensorInfo);

    ARMNN_ASSERT_MSG(layer.GetNumInputSlots() == 1, ""Output Layer should have exactly one input."");

    // Gets the output handler from the previous node.
    const OutputHandler& outputHandler = layer.GetInputSlots()[0].GetConnectedOutputSlot()->GetOutputHandler();

    const TensorInfo& inputTensorInfo = outputHandler.GetTensorInfo();
    ITensorHandle* inputTensorHandle = outputHandler.GetData();
    ARMNN_ASSERT_MSG(inputTensorHandle != nullptr, ""Data should have been allocated."");

    // Try import the output tensor.
    // Note: We can only import the output pointer if all of the following  hold true:
    // a) The imported pointer is aligned sufficiently
    // b) The tensor has zero padding
    // c) There is only one connection to the OutputSlot and it is to an OutputLayer.
    // d) The output pointer is allocated via malloc. (Other types will be supported in a later release)
    // e) m_IsExportEnabled must be set to true
    bool needMemCopy = true;
    if (m_NetworkProperties.m_ExportEnabled &&
        (layer.GetInputSlots()[0].GetConnectedOutputSlot()->GetNumConnections() == 1))
    {
        if(layer.GetInputSlots()[0].GetConnectedOutputSlot()->GetOwningLayer().GetType() != LayerType::Input)
        {
            MemorySourceFlags importFlags = inputTensorHandle->GetImportFlags();
            if (CheckFlag(importFlags, m_NetworkProperties.m_OutputSource))
            {
                needMemCopy = false;
                void *mem = tensorHandle->Map(false);
                bool importOk = inputTensorHandle->Import(mem, m_NetworkProperties.m_OutputSource);
                tensorHandle->Unmap();

                if (importOk)
                {
                    // Insert synchronization workload
                    MemSyncQueueDescriptor syncDesc;
                    syncDesc.m_Inputs.push_back(inputTensorHandle);
                    info.m_InputTensorInfos.push_back(inputTensorInfo);
                    auto syncWorkload = std::make_unique<SyncMemGenericWorkload>(syncDesc, info);
                    ARMNN_ASSERT_MSG(syncWorkload, ""No sync workload created"");
                    m_OutputQueue.push_back(move(syncWorkload));
                }
                else
                {
                    throw MemoryExportException(""EnqueueOutput: Memory Export failed"");
                }
            }
        }
    }
    if (needMemCopy)
    {
        // If we got here then we didn't export the memory, so add an output workload which performs a memcopy.
        outputQueueDescriptor.m_Inputs.push_back(inputTensorHandle);
        info.m_InputTensorInfos.push_back(inputTensorInfo);

        std::unique_ptr<IWorkload> outputWorkload =
            std::make_unique<CopyMemGenericWorkload>(outputQueueDescriptor, info);
        ARMNN_ASSERT_MSG(outputWorkload, ""No output workload created"");

        std::unique_ptr<TimelineUtilityMethods> timelineUtils =
            TimelineUtilityMethods::GetTimelineUtils(m_ProfilingService);
        if (timelineUtils)
        {
            // Add Output Workload to the post-optimisation network structure
            AddWorkloadStructure(timelineUtils, outputWorkload, layer);
            timelineUtils->Commit();
        }

        m_OutputQueue.push_back(move(outputWorkload));
    }
}

void LoadedNetwork::AllocateWorkingMemory(std::lock_guard<std::mutex>& lock)
{
    ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""Working Memory Allocation"");

    // this unused parameter makes sure we can only call this function with a valid lock
    IgnoreUnused(lock);

    if (m_IsWorkingMemAllocated)
    {
        return;
    }

    if (m_ExternalMemoryManager)
    {
        m_ExternalMemoryManager->Allocate();

        for (unsigned int i = 0; i < m_TensorMemory.size(); ++i)
        {
            m_Tensorhandles[i]->Import(m_TensorMemory[i].first->m_Data, m_TensorMemory[i].second);
        }
    }

    for (auto&& memoryManager : m_BackendMemoryMangers)
    {
        if (memoryManager)
        {
            memoryManager->Acquire();
        }
    }
    m_TensorHandleFactoryRegistry.AquireMemory();
    m_IsWorkingMemAllocated = true;
}

void LoadedNetwork::FreeWorkingMemory()
{
    std::lock_guard<std::mutex> lockGuard(m_WorkingMemMutex);

    if (!m_IsWorkingMemAllocated)
    {
        return;
    }

    if (m_ExternalMemoryManager)
    {
        m_ExternalMemoryManager->Deallocate();
    }

    // Informs the memory managers to release memory in its respective memory group
    for (auto&& memoryManager : m_BackendMemoryMangers)
    {
        if (memoryManager)
        {
            memoryManager->Release();
        }
    }
    m_TensorHandleFactoryRegistry.ReleaseMemory();
    m_IsWorkingMemAllocated = false;
}

bool LoadedNetwork::Execute(std::unique_ptr<TimelineUtilityMethods>& timelineUtils,
                            profiling::ProfilingGuid inferenceGuid)
{
    bool success = true;

    auto Fail = [&](const std::exception& error)
    {
        ARMNN_LOG(error) << ""An error occurred attempting to execute a workload: "" << error.what();
        success = false;
    };

    try
    {
        std::lock_guard<std::mutex> lockGuard(m_WorkingMemMutex);
        AllocateWorkingMemory(lockGuard);

        ProfilingDynamicGuid workloadInferenceID(0);
        auto ExecuteQueue = [&timelineUtils, &workloadInferenceID, &inferenceGuid](WorkloadQueue& queue)
        {
            for (auto& workload : queue)
            {
                if(timelineUtils)
                {
                    workloadInferenceID = timelineUtils->RecordWorkloadInferenceAndStartOfLifeEvent(workload->GetGuid(),
                                                                                                    inferenceGuid);
                }
                workload->Execute();
                if(timelineUtils)
                {
                    timelineUtils->RecordEndOfLifeEvent(workloadInferenceID);
                }
            }
        };

        ExecuteQueue(m_InputQueue);
        ExecuteQueue(m_WorkloadQueue);
        ExecuteQueue(m_OutputQueue);
    }
    catch (const RuntimeException& error)
    {
        Fail(error);
    }
    catch (const std::runtime_error& error)
    {
        Fail(error);
    }

    return success;
}

void LoadedNetwork::EnqueueInput(const ConstTensor& inputTensor, ITensorHandle* inputTensorHandle)
{
    if (m_NetworkProperties.m_ImportEnabled)  // Try import the input tensor
    {
        MemorySourceFlags importFlags = inputTensorHandle->GetImportFlags();
        if (CheckFlag(importFlags, m_NetworkProperties.m_InputSource) )
        {
            std::unique_ptr<ITensorHandle> tensorHandle =
                    std::make_unique<ConstPassthroughTensorHandle>(inputTensor.GetInfo(),
                                                                   inputTensor.GetMemoryArea());
            void* mem = tensorHandle->Map(false);

            if (inputTensorHandle->Import(mem, m_NetworkProperties.m_InputSource))
            {
                tensorHandle->Unmap();
                return;
            }
            tensorHandle->Unmap();
            throw MemoryImportException(""EnqueueInput: Memory Import failed"");
        }
        else
        {
            throw MemoryImportException(""EnqueueInput: Memory Import failed, backend does not support Import"");
        }
    }
    else
    {
        std::unique_ptr<ITensorHandle> tensorHandle =
                std::make_unique<ConstPassthroughTensorHandle>(inputTensor.GetInfo(), inputTensor.GetMemoryArea());

        auto copyFunc = [](void* dst, const void* src, size_t size)
        {
            memcpy(dst, src, size);
        };

        CopyTensorContentsGeneric(tensorHandle.get(), inputTensorHandle, copyFunc);
    }
}

// Note: We can only import the output pointer if all of the following  hold true:
// a) The imported pointer is aligned sufficiently
// b) The tensor has zero padding
// c) There is only one connection to the OutputSlot and it is to an OutputLayer.
// d) The output pointer is allocated via malloc. (Other types will be supported in a later release)
// e) m_IsExportEnabled must be set to true
void LoadedNetwork::ImportOutputTensor(const Tensor& outputTensor, ITensorHandle* outputTensorHandle)
{
    ARMNN_ASSERT_MSG(outputTensorHandle != nullptr, ""Data should have been allocated."");
    MemorySourceFlags importFlags = outputTensorHandle->GetImportFlags();
    if (CheckFlag(importFlags, m_NetworkProperties.m_OutputSource))
    {
        std::unique_ptr<ITensorHandle> tensorHandle =
                std::make_unique<PassthroughTensorHandle>(outputTensor.GetInfo(),
                                                          outputTensor.GetMemoryArea());

        void* mem = tensorHandle->Map(false);
        bool importOk = outputTensorHandle->Import(mem, m_NetworkProperties.m_OutputSource);
        tensorHandle->Unmap();

        if (!importOk)
        {
            throw MemoryExportException(""ImportOutputTensor: Memory Export failed"");
        }
    }
    else
    {
        throw MemoryExportException(""ImportOutputTensor: Memory Export failed, attempting to export Input Layer"");
    }

}

void CopyToOutputTensor(const Tensor& outputTensor, ITensorHandle* outputTensorHandle)
{
    auto copyFunc = [](void* dst, const void* src, size_t size)
    {
        memcpy(dst, src, size);
    };

    std::unique_ptr<ITensorHandle> tensorHandle =
            std::make_unique<PassthroughTensorHandle>(outputTensor.GetInfo(),
                                                      outputTensor.GetMemoryArea());

    CopyTensorContentsGeneric(outputTensorHandle, tensorHandle.get(), copyFunc);
}


const armnn::ConstTensor GetInputTensor(const LayerBindingId layerId, const InputTensors& inputTensors)
{
    for (auto inputTensorPair : inputTensors)
    {
        LayerBindingId id = inputTensorPair.first;
        if (id == layerId)
        {
            return inputTensorPair.second;
        }
    }
    throw InvalidArgumentException(""Input does not exist."");
}

const armnn::Tensor GetOutputTensor(const LayerBindingId layerId, const OutputTensors& outputTensors)
{
    for (auto outputTensorPair : outputTensors)
    {
        LayerBindingId id = outputTensorPair.first;
        if (id == layerId)
        {
            return outputTensorPair.second;
        }
    }
    throw InvalidArgumentException(""Output does not exist."");
}

std::vector<ImportedInputId> LoadedNetwork::ImportInputs(const InputTensors& inputTensors)
{
    if (!m_NetworkProperties.m_ImportEnabled)  // Try import the input tensor
    {
        throw MemoryImportException(""ImportInputs: Memory Import failed, NetworkProperties.m_ImportEnabled"");
    }

    std::vector<ImportedInputId> importedInputs;
    Graph& graph = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().TopologicalSort();

    for (auto inputTensor : inputTensors)
    {
        auto layerBindingId = inputTensor.first;
        auto it = std::find_if(graph.GetInputLayers().begin(), graph.GetInputLayers().end(), [=](auto* layer)
        {
            return layer->GetBindingId() == layerBindingId;
        });

        if (it == graph.GetInputLayers().end())
        {
            throw MemoryImportException(fmt::format(""ImportInputs: Memory Import failed, unknown LayerBindingId: {}"",
                                                    layerBindingId));
        }

        const Layer* layer = *it;
        if (layer->GetType() != LayerType::Input)
        {
            throw InvalidArgumentException(""ImportInputs: given layer not an InputLayer"");
        }

        auto& backend = m_Backends.at(layer->GetBackendId());
        if (!HasCapability(BackendOptions::BackendOption{""PreImportIOTensors"", true}, backend->GetCapabilities()))
        {
            std::string er = backend->GetId();
            er += "" does not have PreImportIOTensors capability"";
            throw BackendCapabilityException(er);
        }

        const OutputSlot& outputSlot = layer->GetOutputSlots()[0];

        ITensorHandleFactory::FactoryId factoryId = outputSlot.GetTensorHandleFactoryId();
        const TensorInfo& tensorInfo = outputSlot.GetTensorInfo();

        ITensorHandleFactory* handleFactory = m_TensorHandleFactoryRegistry.GetFactory(factoryId);
        ARMNN_ASSERT(handleFactory);

        ImportedTensorHandlePin importedTensorHandlePin{layerBindingId,
                                                        handleFactory->CreateTensorHandle(tensorInfo, false)};

        ITensorHandle* tensorHandle = importedTensorHandlePin.m_TensorHandle.get();

        if (!CheckFlag(tensorHandle->GetImportFlags(), m_NetworkProperties.m_InputSource))
        {
            throw MemoryImportException(
                fmt::format(""ImportInputs: Memory Import failed, backend: {} does not support importing from source {}""
                            , factoryId, m_NetworkProperties.m_InputSource));
        }

        std::unique_ptr<ITensorHandle> passThroughTensorHandle =
                std::make_unique<ConstPassthroughTensorHandle>(inputTensor.second.GetInfo(),
                                                               inputTensor.second.GetMemoryArea());

        if (tensorHandle->Import(passThroughTensorHandle->Map(), m_NetworkProperties.m_InputSource))
        {
            importedInputs.push_back(m_CurImportedInputId++);
            passThroughTensorHandle->Unmap();
        }
        else
        {
            passThroughTensorHandle->Unmap();
            throw MemoryImportException(""ImportInputs: Memory Import failed"");
        }

        m_PreImportedInputHandles.push_back(std::move(importedTensorHandlePin));
    }

    return importedInputs;
}

std::vector<ImportedOutputId> LoadedNetwork::ImportOutputs(const OutputTensors& outputTensors)
{
    if (!m_NetworkProperties.m_ExportEnabled)  // Try import the output tensor
    {
        throw MemoryImportException(""ImportOutputs: Memory Import failed, NetworkProperties.m_ImportEnabled"");
    }

    std::vector<ImportedOutputId> importedOutputs;
    Graph& graph = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().TopologicalSort();

    for (const auto& outputTensor : outputTensors)
    {
        auto layerBindingId = outputTensor.first;
        auto it = std::find_if(graph.GetOutputLayers().begin(), graph.GetOutputLayers().end(), [=](auto* layer)
        {
            return layer->GetBindingId() == layerBindingId;
        });

        if (it == graph.GetOutputLayers().end())
        {
            throw MemoryImportException(fmt::format(""ImportOutputs: Memory Import failed, unknown LayerBindingId: {}"",
                                                     layerBindingId));
        }

        const Layer* layer = *it;
        if (layer->GetType() != LayerType::Output)
        {
            throw InvalidArgumentException(""ImportOutputs: given layer not an OutputLayer"");
        }

        auto& backend = m_Backends.at(layer->GetBackendId());
        if (!HasCapability(BackendOptions::BackendOption{""PreImportIOTensors"", true}, backend->GetCapabilities()))
        {
            std::string er = backend->GetId();
            er += "" does not have PreImportIOTensors capability"";
            throw BackendCapabilityException(er);
        }

        const InputSlot& inputSlot = layer->GetInputSlots()[0];
        ITensorHandleFactory::FactoryId factoryId = inputSlot.GetConnectedOutputSlot()->GetTensorHandleFactoryId();
        const TensorInfo& tensorInfo = inputSlot.GetConnectedOutputSlot()->GetTensorInfo();

        ITensorHandleFactory* handleFactory = m_TensorHandleFactoryRegistry.GetFactory(factoryId);
        ARMNN_ASSERT(handleFactory);

        ImportedTensorHandlePin importedTensorHandlePin{layerBindingId,
                                                        handleFactory->CreateTensorHandle(tensorInfo, false)};

        ITensorHandle* tensorHandle = importedTensorHandlePin.m_TensorHandle.get();

        if (!CheckFlag(tensorHandle->GetImportFlags(), m_NetworkProperties.m_OutputSource))
        {
            throw MemoryImportException(fmt::format(""ImportInputs: Memory Import failed, backend: ""
                                                    ""{} does not support importing from source {}""
                                                    , factoryId, m_NetworkProperties.m_OutputSource));
        }

        if (tensorHandle->Import(outputTensor.second.GetMemoryArea(), m_NetworkProperties.m_OutputSource))
        {
            importedOutputs.push_back(m_CurImportedOutputId++);
        }
        else
        {
            throw MemoryImportException(""ImportInputs: Memory Import failed"");
        }

        m_PreImportedOutputHandles.push_back(std::move(importedTensorHandlePin));
    }

    return importedOutputs;
}

void LoadedNetwork::ClearImportedInputs(const std::vector<ImportedInputId> inputIds)
{
    for (auto id : inputIds)
    {
        if (id > m_PreImportedInputHandles.size())
        {
            throw InvalidArgumentException(fmt::format(""ClearImportedInputs::Unknown ImportedInputId: {}"", id));
        }

        auto& importedTensorHandle = m_PreImportedInputHandles[id].m_TensorHandle;
        if (!importedTensorHandle)
        {
            throw InvalidArgumentException(
                    fmt::format(""ClearImportedInputs::ImportedInput with id: {} has already been deleted"", id));
        }
        // Call Unimport then destroy the tensorHandle
        importedTensorHandle->Unimport();
        importedTensorHandle = {};
    }
}

void LoadedNetwork::ClearImportedOutputs(const std::vector<ImportedOutputId> outputIds)
{
    for (auto id : outputIds)
    {
        if (id > m_PreImportedOutputHandles.size())
        {
            throw InvalidArgumentException(fmt::format(""ClearImportedOutputs::Unknown ImportedOutputId: {}"", id));
        }

       auto& importedTensorHandle = m_PreImportedOutputHandles[id].m_TensorHandle;
       if (!importedTensorHandle)
       {
           throw InvalidArgumentException(
                   fmt::format(""ClearImportedOutputs::ImportedOutput with id: {} has already been deleted"", id));
       }
       // Call Unimport then destroy the tensorHandle
       importedTensorHandle->Unimport();
       importedTensorHandle = {};
    }
}

Status LoadedNetwork::Execute(const InputTensors& inputTensors,
                              const OutputTensors& outputTensors,
                              IWorkingMemHandle& iWorkingMemHandle,
                              std::vector<ImportedInputId> preImportedInputs,
                              std::vector<ImportedOutputId> preImportedOutputs)
{
    const Graph& graph = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph();

    if (inputTensors.size() + preImportedInputs.size() != graph.GetNumInputs())
    {
        if (preImportedInputs.empty())
        {
            throw InvalidArgumentException(""LoadedNetwork::Execute: Number of inputs provided does not match network."");
        }
        else
        {
            throw InvalidArgumentException(""LoadedNetwork::Execute: ""
                                           ""Number of inputs + preImportedInputs provided does not match network."");
        }
    }

    if (outputTensors.size() + preImportedOutputs.size() != graph.GetNumOutputs())
    {
        if (preImportedOutputs.empty())
        {
            throw InvalidArgumentException(""LoadedNetwork::Execute: ""
                                           ""Number of outputs provided does not match network."");
        }
        else
        {
            throw InvalidArgumentException(""LoadedNetwork::Execute: ""
                                           ""Number of outputs + preImportedOutputs provided does not match network."");
        }
    }

    WorkingMemHandle& workingMemHandle = dynamic_cast<WorkingMemHandle&>(iWorkingMemHandle);
    // Collect all the given LayerBindingIds and check them for duplicates and unknowns.
    std::vector<LayerBindingId>& bindingIds = workingMemHandle.GetBindingIdVector();
    unsigned int index = 0;
    for (auto pair : inputTensors)
    {
        bindingIds[index++] = pair.first;
    }
    for (ImportedInputId id : preImportedInputs)
    {
        bindingIds[index++] = ValidateImportedInputID(id);
    }
    for (auto pair : outputTensors)
    {
        bindingIds[index++] = pair.first;
    }
    for (ImportedOutputId id : preImportedOutputs)
    {
        bindingIds[index++] = ValidateImportedOutputID(id);
    }

    workingMemHandle.ValidateBindingIds();

    auto resetMemHandle = [&]()
    {
        for (ImportedInputId id: preImportedInputs)
        {
            const LayerBindingId layerBindingId = m_PreImportedInputHandles[id].m_LayerBindingId;

            auto inputHandle = workingMemHandle.GetInputHandle(layerBindingId);
            auto inputConnections = workingMemHandle.GetInputConnections(layerBindingId);
            for (auto it : inputConnections)
            {
                *it = inputHandle;
            }
        }

        for (ImportedOutputId id: preImportedOutputs)
        {
            const LayerBindingId layerBindingId = m_PreImportedOutputHandles[id].m_LayerBindingId;

            auto outputHandle = workingMemHandle.GetOutputHandle(layerBindingId);
            auto outputConnections = workingMemHandle.GetOutputConnection(layerBindingId);

            for (auto it : outputConnections)
            {
                *it = outputHandle;
            }
        }
    };

    std::unique_ptr<profiling::TimelineUtilityMethods> timelineUtils =
            profiling::TimelineUtilityMethods::GetTimelineUtils(m_ProfilingService);
    profiling::ProfilingGuid inferenceGuid = m_ProfilingService.GetNextGuid();
    if (timelineUtils)
    {
        // Add inference timeline trace if profiling is enabled.
        profiling::ProfilingGuid networkGuid = m_OptimizedNetwork->GetGuid();
        timelineUtils->CreateTypedEntity(inferenceGuid, profiling::LabelsAndEventClasses::INFERENCE_GUID);
        timelineUtils->CreateRelationship(profiling::ProfilingRelationshipType::RetentionLink,
                                          networkGuid,
                                          inferenceGuid,
                                          profiling::LabelsAndEventClasses::EXECUTION_OF_GUID);
        timelineUtils->RecordEvent(inferenceGuid, profiling::LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
    }

    bool executionSucceeded = true;

    if (timelineUtils)
    {
        // Add end of life of the inference timeline if profiling is enabled.
        timelineUtils->RecordEvent(inferenceGuid, profiling::LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
        timelineUtils->Commit();
    }

    if (!workingMemHandle.IsAllocated())
    {
        workingMemHandle.Allocate();
    }

    {
        ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""PrepareInputs"");
        for (auto pair : inputTensors)
        {
            EnqueueInput(pair.second, workingMemHandle.GetInputHandle(pair.first));
        }

        // Swap in the pre-imported inputs if any
        for (ImportedInputId id : preImportedInputs)
        {
            const ImportedTensorHandlePin& importedInputPin = m_PreImportedInputHandles[id];
            const LayerBindingId layerBindingId = m_PreImportedInputHandles[id].m_LayerBindingId;
            const auto& preimportedHandle = importedInputPin.m_TensorHandle;

            auto inputConnections = workingMemHandle.GetInputConnections(layerBindingId);
            for (auto it : inputConnections)
            {
                *it = preimportedHandle.get();
            }
        }
    }
    {
        ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""PrepareOutputs"");
        if (m_NetworkProperties.m_ExportEnabled)
        {
            for (auto pair: outputTensors)
            {
                ImportOutputTensor(pair.second, workingMemHandle.GetOutputHandle(pair.first));
            }
        }

        for (ImportedOutputId id : preImportedOutputs)
        {
            const ImportedTensorHandlePin& importedOutputPin = m_PreImportedOutputHandles[id];
            const LayerBindingId layerBindingId = m_PreImportedOutputHandles[id].m_LayerBindingId;
            const auto& preimportedHandle = importedOutputPin.m_TensorHandle;

            auto outputConnections = workingMemHandle.GetOutputConnection(layerBindingId);

            for (auto it : outputConnections)
            {
                *it = preimportedHandle.get();
            }
        }
    }

    auto Fail = [&](const std::exception& error)
    {
        ARMNN_LOG(error) << ""An error occurred attempting to execute a workload: "" << error.what();
        executionSucceeded = false;
    };
    profiling::ProfilingDynamicGuid workloadInferenceID(0);

    try
    {
        for (unsigned int i = 0; i < m_WorkloadQueue.size(); ++i)
        {
            auto& workload = m_WorkloadQueue[i];
            if (timelineUtils)
            {
                workloadInferenceID = timelineUtils->RecordWorkloadInferenceAndStartOfLifeEvent(workload->GetGuid(),
                                                                                                inferenceGuid);
            }
            workload->ExecuteAsync(workingMemHandle.GetWorkingMemDescriptorAt(i));

            if (timelineUtils)
            {
                timelineUtils->RecordEndOfLifeEvent(workloadInferenceID);
            }
        }
    }
    catch (const RuntimeException& error)
    {
        resetMemHandle();
        Fail(error);
    }
    catch (const std::runtime_error& error)
    {
        resetMemHandle();
        Fail(error);
    }
    catch (...)
    {
        resetMemHandle();
        throw;
    }

    if (!m_NetworkProperties.m_ExportEnabled)
    {
        for (auto pair: outputTensors)
        {
            CopyToOutputTensor(pair.second, workingMemHandle.GetOutputHandle(pair.first));
        }
    }
    else
    {
       ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, ""SyncMemGeneric_Execute"");
       workingMemHandle.MemSyncOutputs();
    }

    resetMemHandle();

    return executionSucceeded ? Status::Success : Status::Failure;
}

/// Create a new unique WorkingMemHandle object. Create multiple handles if you wish to have
/// overlapped Execution by calling this function from different threads.
std::unique_ptr<IWorkingMemHandle> LoadedNetwork::CreateWorkingMemHandle(NetworkId networkId)
{
    Graph& order = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph();

    // Tensors that will need to be allocated internally within armnn
    std::vector<std::unique_ptr<ITensorHandle>> managedTensorHandles;
    // Tensors that will be allocated externally by the user
    std::vector<std::unique_ptr<ITensorHandle>> unmanagedTensorHandles;

    std::vector<WorkingMemDescriptor> workingMemDescriptors;
    std::unordered_map<LayerGuid, WorkingMemDescriptor> workingMemDescriptorMap;

    auto GetTensorHandle = [&](Layer* layer, const OutputSlot& outputSlot)
    {
        ITensorHandleFactory::FactoryId factoryId = outputSlot.GetTensorHandleFactoryId();
        const TensorInfo& tensorInfo = outputSlot.GetTensorInfo();

        if (factoryId == ITensorHandleFactory::LegacyFactoryId)
        {
            BackendId id = layer->GetBackendId();
            ARMNN_NO_DEPRECATE_WARN_BEGIN
            return m_WorkloadFactories.at(id)->CreateTensorHandle(tensorInfo, false);
            ARMNN_NO_DEPRECATE_WARN_END
        }
        else
        {
            ITensorHandleFactory* handleFactory = m_TensorHandleFactoryRegistry.GetFactory(factoryId);
            ARMNN_ASSERT(handleFactory);
            return handleFactory->CreateTensorHandle(tensorInfo, false);
        }
    };

    struct HandleInfo
    {
        ITensorHandle* m_TensorHandle;

        bool m_IsInputLayerHandle = false;
        bool m_IsOutputLayerHandle = false;

        WorkingMemHandle::InputMemDescriptorCoords m_InputMemDescriptorCoords;
        WorkingMemHandle::OutputMemDescriptorCoords m_OutputMemDescriptorCoords;
    };

    std::unordered_map<const OutputSlot*, HandleInfo> outputToHandleInfoMap;

    unsigned int layerIndex = 0;
    for (auto&& layer : order)
    {
        // Constant layers execution and management is handled during loaded network construction
        if (layer->GetType() == LayerType::Constant)
        {
            continue;
        }

        WorkingMemDescriptor workingMemDescriptor;

        bool isMemoryManaged = true;
        bool isInputLayer = false;
        bool isOutputLayer = false;
        bool isConnectedToOutputLayer = false;

        if (layer->GetType() == LayerType::Input || layer->GetType() == LayerType::MemImport)
        {
            // Input layers/workloads will not be executed so the descriptor is not added to workingMemDescriptors
            // However we will still need to manage the tensorHandle
            isInputLayer = true;
            isMemoryManaged = !m_NetworkProperties.m_ImportEnabled;
        }
        else if (layer->GetType() == LayerType::Output)
        {
            isOutputLayer = true;
        }

        unsigned int slotIndex = 0;
        // Create a tensor handle for each output slot of a layer
        // Once we create it, we start managing its lifetime
        for (auto& slot : layer->GetOutputSlots())
        {
            for (unsigned int i = 0; i < slot.GetNumConnections(); ++i)
            {
                if ((slot.GetConnection(i)->GetOwningLayer().GetType() == LayerType::Output))
                {
                    if (!isConnectedToOutputLayer)
                    {
                        isConnectedToOutputLayer = true;
                        // If Export is enabled disable memory management, so we can export, otherwise we do a copy
                        isMemoryManaged = !m_NetworkProperties.m_ExportEnabled;
                    }
                    else
                    {
                        // Importing in this case would likely cause unexpected behaviour, so we disallow it.
                        ARMNN_LOG(warning) <<
                           fmt::format(""Layer name: '{0}' guid: '{1}' has two or more OutputLayers connected to it. ""
                                       ""This will prevent importing on the connected OutputLayers."",
                                        layer->GetName(), layer->GetGuid());
                        isMemoryManaged = true;
                    }
                }
            }

            ITensorHandle* tensorHandle;
            if (isMemoryManaged)
            {
                managedTensorHandles.emplace_back(GetTensorHandle(layer, slot));
                tensorHandle = managedTensorHandles.back().get();
            }
            else
            {
                unmanagedTensorHandles.emplace_back(GetTensorHandle(layer, slot));
                tensorHandle = unmanagedTensorHandles.back().get();
            }

            workingMemDescriptor.m_Outputs.push_back(tensorHandle);

            HandleInfo& handleInfo = outputToHandleInfoMap[&slot];
            handleInfo.m_TensorHandle = tensorHandle;

            // Store the coordinates of the current layer's OutputSlot that is connected to the OutputLayer
            if (isConnectedToOutputLayer)
            {
                handleInfo.m_IsOutputLayerHandle = true;
                handleInfo.m_OutputMemDescriptorCoords.m_OutputSlotCoords = {layerIndex, slotIndex};
            }
            // Store the LayerBindingId of the InputLayer
            if (isInputLayer)
            {
                handleInfo.m_IsInputLayerHandle = true;
                LayerBindingId bindingId = static_cast<BindableLayer*>(layer)->GetBindingId();
                handleInfo.m_InputMemDescriptorCoords.m_LayerBindingId = bindingId;
            }
            slotIndex++;
        }
        // Loop through the input slots in the same layer and decrement the reference counter associated
        // to each tensor handle we encounter.
        // Once it reaches zero, the lifetime of the tensor handle has ended, and we mark its memory as available
        // so that the next tensor handle with a non overlapping lifetime can share its memory.
        for (auto& slot : layer->GetInputSlots())
        {
            ARMNN_ASSERT(slot.GetConnection());
            auto outputSlot = slot.GetConnectedOutputSlot();
            auto key = outputSlot->GetOwningLayer().GetGuid();

            // Constant layers execution and management is handled during loaded network construction
            auto found = m_ConstantTensorHandles.find(key);
            if (found != m_ConstantTensorHandles.end())
            {
                ITensorHandle* tensorHandle = found->second;
                workingMemDescriptor.m_Inputs.push_back(tensorHandle);

                // Odd case where a constant layer is connected to an output layer
                // We will need to create a HandleInfo to track it
                if (isOutputLayer)
                {
                    LayerBindingId bindingId = static_cast<BindableLayer*>(layer)->GetBindingId();

                    HandleInfo& handleInfo = outputToHandleInfoMap[outputSlot];
                    handleInfo.m_TensorHandle = tensorHandle;
                    handleInfo.m_IsOutputLayerHandle = true;
                    handleInfo.m_OutputMemDescriptorCoords.m_LayerBindingIds.push_back(bindingId);
                    handleInfo.m_OutputMemDescriptorCoords.m_InputSlotCoords.push_back({layerIndex, 0});
                }
                continue;
            }

            HandleInfo& handleInfo = outputToHandleInfoMap.at(outputSlot);

            ITensorHandle* inputTensorHandle = handleInfo.m_TensorHandle;
            workingMemDescriptor.m_Inputs.push_back(inputTensorHandle);

            // Store the LayerBindingId of the OutputLayer
            if (isOutputLayer)
            {
                LayerBindingId bindingId = static_cast<BindableLayer*>(layer)->GetBindingId();
                handleInfo.m_OutputMemDescriptorCoords.m_LayerBindingIds.push_back(bindingId);
                handleInfo.m_OutputMemDescriptorCoords.m_InputSlotCoords.push_back({layerIndex, 0});
            }
            // In this case the layer is not an Output Layer but shares its input tensorhandle with an OutputLayer
            // It will need to be updated as well, if we swap out the tensorhandle
            else if (handleInfo.m_IsOutputLayerHandle)
            {
                handleInfo.m_OutputMemDescriptorCoords.m_InputSlotCoords.push_back({layerIndex, slot.GetSlotIndex()});
            }

            // Store the coordinates of the InputSlots connected to the InputLayer
            // There can be more than one InputSlot connected to an InputLayer, so we use a vector
            if (handleInfo.m_IsInputLayerHandle)
            {
                std::pair<LayerGuid, unsigned int> connectionLocation{layerIndex, slot.GetSlotIndex()};
                handleInfo.m_InputMemDescriptorCoords.m_InputSlotCoords.emplace_back(connectionLocation);
            }
        }
        workingMemDescriptorMap.insert({layer->GetGuid(), workingMemDescriptor});

        // Input/Output layers/workloads will not be executed, so the descriptor is not added to workingMemDescriptors
        // However we will still need to manage the tensorHandle
        if (!isInputLayer)
        {
            workingMemDescriptors.push_back(workingMemDescriptor);
            layerIndex++;
        }
    }

    std::vector<std::pair<std::shared_ptr<TensorMemory>, MemorySource>> tensorMemory;

    auto externalMemoryManager = CreateExternalMemoryManger(tensorMemory);

    // Sort m_TensorMemory, so it's order matches the outputSlot order
    std::sort(tensorMemory.begin(), tensorMemory.end(),
              [](const std::pair<std::shared_ptr<TensorMemory>, MemorySource>& lhs,
                 const std::pair<std::shared_ptr<TensorMemory>, MemorySource>& rhs)
              {
                  return lhs.first->m_OutputSlotId < rhs.first->m_OutputSlotId;
              });

    std::vector<WorkingMemHandle::InputMemDescriptorCoords> inputConnectionsInfo;
    std::vector<WorkingMemHandle::OutputMemDescriptorCoords> outputConnectionsInfo;

    for (const auto& handleInfo: outputToHandleInfoMap)
    {
        if (handleInfo.second.m_IsOutputLayerHandle)
        {
            outputConnectionsInfo.emplace_back(handleInfo.second.m_OutputMemDescriptorCoords);
        }

        if (handleInfo.second.m_IsInputLayerHandle)
        {
            inputConnectionsInfo.emplace_back(handleInfo.second.m_InputMemDescriptorCoords);
        }
    }

    return std::make_unique<WorkingMemHandle>(networkId,
                                              inputConnectionsInfo,
                                              outputConnectionsInfo,
                                              workingMemDescriptors,
                                              workingMemDescriptorMap,
                                              std::move(externalMemoryManager),
                                              std::move(tensorMemory),
                                              std::move(managedTensorHandles),
                                              std::move(unmanagedTensorHandles));
}

void LoadedNetwork::RegisterDebugCallback(const DebugCallbackFunction& func)
{
    for (auto&& workloadPtr: m_WorkloadQueue)
    {
        workloadPtr.get()->RegisterDebugCallback(func);
    }
}


void LoadedNetwork::CreateMemoryProfileAsync()
{
    struct PartialBlock
    {
        unsigned int m_StartOfLife;
        unsigned int m_Lifetime;

        size_t m_MemSize;
        unsigned int m_Index;

        BackendId m_BackendId;
    };

    auto align = [](size_t numToAlign)
    {
        const size_t alignment = sizeof(float);
        return ((numToAlign + alignment - 1) / alignment) * alignment;
    };

    std::unordered_map<const OutputSlot*, PartialBlock> memBlockTrackerMap;

    const bool inputImportingEnabled = m_NetworkProperties.m_InputSource != MemorySource::Undefined;
    const bool outputImportingEnabled = m_NetworkProperties.m_OutputSource != MemorySource::Undefined;

    unsigned int timestep = 0;
    unsigned int outputIndex = 0;
    Graph& order = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().TopologicalSort();

    for (auto&& layer : order)
    {
        const LayerType& layerType = layer->GetType();
        // Don't manage memory if importing.
        if (layerType == LayerType::Input && inputImportingEnabled)
        {
            continue;
        }
        // Don't manage memory if importing.
        if (layerType == LayerType::Output && outputImportingEnabled
            && layer->GetInputSlot(0).GetConnectedOutputSlot()->GetNumConnections() == 1)
        {
            continue;
        }
        // Because Constant Layer memory can not be shared, the memory must persist for the lifetime of execution,
        // management is done separately.
        if (layerType == LayerType::Constant)
        {
            continue;
        }

        BackendId backendId = layer->GetBackendId();
        for (auto& outputSlot : layer->GetOutputSlots())
        {
            if (!m_SupportsExternallyManagedMemory[backendId])
            {
                continue;
            }

            PartialBlock partialBlock;

            partialBlock.m_StartOfLife = timestep;

            size_t alignedSize = align(outputSlot.GetOutputHandler().GetTensorInfo().GetNumBytes());
            partialBlock.m_MemSize = alignedSize;
            partialBlock.m_Index = outputIndex++;
            partialBlock.m_Lifetime = outputSlot.GetNumConnections();
            partialBlock.m_BackendId = backendId;

            if (partialBlock.m_Lifetime == 0)
            {
                m_MemBlockMap[partialBlock.m_BackendId].emplace_back(partialBlock.m_StartOfLife,
                                                                     partialBlock.m_StartOfLife,
                                                                     partialBlock.m_MemSize,
                                                                     0,
                                                                     partialBlock.m_Index);
            }
            else
            {
                memBlockTrackerMap[&outputSlot] = partialBlock;
            }
        }

        for (auto& inputSlot : layer->GetInputSlots())
        {
            const Layer& connectedInputLayer = inputSlot.GetConnectedOutputSlot()->GetOwningLayer();
            const LayerType& owningLayerType = connectedInputLayer.GetType();

            if (owningLayerType == LayerType::Constant)
            {
                continue;
            }
            if (inputImportingEnabled && owningLayerType == LayerType::Input)
            {
                continue;
            }

            auto outputSlot = inputSlot.GetConnectedOutputSlot();

            PartialBlock& partialBlock = memBlockTrackerMap.at(outputSlot);

            auto& lifetime = partialBlock.m_Lifetime;
            --lifetime;

            if (lifetime == 0)
            {
                m_MemBlockMap[partialBlock.m_BackendId].emplace_back(partialBlock.m_StartOfLife,
                                                                     timestep,
                                                                     partialBlock.m_MemSize,
                                                                     0,
                                                                     partialBlock.m_Index);
            }
        }
        ++timestep;
    }
}

void LoadedNetwork::CreateMemoryProfile()
{
    // Finds the first TensorHandle ancestor of a SubTensorHandle. If the ITensorHandle provided
    // is a TensorHandle, the function just returns it
    auto TraceSubTensorHandleAncestry = [](ITensorHandle* const subTensorHandle)
    {
        ITensorHandle* ancestor = subTensorHandle;
        while (ancestor && ancestor->GetParent())
        {
            ancestor = ancestor->GetParent();
        }
        return ancestor;
    };

    struct PartialBlock
    {
        unsigned int m_StartOfLife;
        unsigned int m_Lifetime;

        size_t m_MemSize;
        unsigned int m_Index;

        BackendId m_BackendId;
    };

    auto align = [](size_t numToAlign)
    {
        const size_t alignment = sizeof(float);
        return ((numToAlign + alignment - 1) / alignment) * alignment;
    };

    std::unordered_map<ITensorHandle*, PartialBlock> memBlockTrackerMap;

    const bool inputImportingEnabled = m_NetworkProperties.m_InputSource != MemorySource::Undefined;
    const bool outputImportingEnabled = m_NetworkProperties.m_OutputSource != MemorySource::Undefined;

    unsigned int timestep = 0;
    unsigned int outputIndex = 0;
    Graph& order = m_OptimizedNetwork->pOptimizedNetworkImpl->GetGraph().TopologicalSort();

    for (auto&& layer : order)
    {
        const LayerType& layerType = layer->GetType();
        // Don't manage memory if importing.
        if (layerType == LayerType::Input && inputImportingEnabled)
        {
            continue;
        }
        // Don't manage memory if importing.
        if (layerType == LayerType::Output && outputImportingEnabled
            && layer->GetInputSlot(0).GetConnectedOutputSlot()->GetNumConnections() == 1)
        {
            continue;
        }
        // Because Constant Layer memory can not be shared, the memory must persist for the lifetime of execution,
        // management is done separately.
        if (layerType == LayerType::Constant)
        {
            continue;
        }

        BackendId backendId = layer->GetBackendId();
        for (auto& outputSlot : layer->GetOutputSlots())
        {
            if (!m_SupportsExternallyManagedMemory[backendId])
            {
                continue;
            }

            ITensorHandle* tensorHandle = outputSlot.GetOutputHandler().GetData();
            tensorHandle = TraceSubTensorHandleAncestry(tensorHandle);

            if (memBlockTrackerMap.find(tensorHandle) == memBlockTrackerMap.end())
            {
                PartialBlock partialBlock;

                partialBlock.m_StartOfLife = timestep;

                size_t alignedSize = align(outputSlot.GetOutputHandler().GetTensorInfo().GetNumBytes());
                partialBlock.m_MemSize = alignedSize;
                partialBlock.m_Index = outputIndex++;
                partialBlock.m_Lifetime = outputSlot.GetNumConnections();
                partialBlock.m_BackendId = backendId;

                if (partialBlock.m_Lifetime == 0)
                {
                    m_MemBlockMap[partialBlock.m_BackendId].emplace_back(partialBlock.m_StartOfLife,
                                                                         partialBlock.m_StartOfLife,
                                                                         partialBlock.m_MemSize,
                                                                         0,
                                                                         partialBlock.m_Index);
                }
                else
                {
                    memBlockTrackerMap[tensorHandle] = partialBlock;
                }
                m_Tensorhandles.push_back(tensorHandle);

            }
            else
            {
                memBlockTrackerMap.at(tensorHandle).m_Lifetime += outputSlot.GetNumConnections();
            }
        }

        for (auto& inputSlot : layer->GetInputSlots())
        {
            const Layer& connectedInputLayer = inputSlot.GetConnectedOutputSlot()->GetOwningLayer();
            const LayerType& owningLayerType = connectedInputLayer.GetType();

            if (owningLayerType == LayerType::Constant)
            {
                continue;
            }
            if (inputImportingEnabled && owningLayerType == LayerType::Input)
            {
                continue;
            }
            if (!m_SupportsExternallyManagedMemory[connectedInputLayer.GetBackendId()])
            {
                continue;
            }

            auto outputSlot = inputSlot.GetConnectedOutputSlot();

            ITensorHandle* tensorHandle = outputSlot->GetOutputHandler().GetData();
            tensorHandle = TraceSubTensorHandleAncestry(tensorHandle);

            PartialBlock& partialBlock = memBlockTrackerMap.at(tensorHandle);

            auto& lifetime = partialBlock.m_Lifetime;
            --lifetime;

            if (lifetime == 0)
            {
                m_MemBlockMap[partialBlock.m_BackendId].emplace_back(partialBlock.m_StartOfLife,
                                                                     timestep,
                                                                     partialBlock.m_MemSize,
                                                                     0,
                                                                     partialBlock.m_Index);
            }
        }
        ++timestep;
    }

}

std::unique_ptr<MemoryManager> LoadedNetwork::CreateExternalMemoryManger(
        std::vector<std::pair<std::shared_ptr<TensorMemory>, MemorySource>>& tensorMemoryVec)
{
    std::unique_ptr<MemoryManager> memoryManager = std::make_unique<MemoryManager>();
    auto allocatorMap = BackendRegistryInstance().GetAllocators();

    for (auto& backend : m_MemBinMap)
    {
        std::vector<BufferStorage> bufferStorageVec;

        std::shared_ptr<ICustomAllocator> backendAllocator;
        if (allocatorMap.find(backend.first) != allocatorMap.end())
        {
            backendAllocator = allocatorMap[backend.first];
        }
        else
        {
            backendAllocator = m_Backends[backend.first]->GetDefaultAllocator();
        }

        for (auto& memBin : backend.second)
        {
            BufferStorage bufferStorage;
            bufferStorage.m_BufferSize = memBin.m_MemSize;
            bufferStorage.m_TensorMemoryVector.reserve(memBin.m_MemBlocks.size());

            for (auto& memBlock : memBin.m_MemBlocks)
            {
                auto tensorMemory = std::make_shared<TensorMemory>(TensorMemory{memBlock.m_Offset, memBlock.m_Index});

                tensorMemoryVec.emplace_back(tensorMemory, backendAllocator->GetMemorySourceType());
                bufferStorage.m_TensorMemoryVector.emplace_back(tensorMemory);
            }

            bufferStorageVec.emplace_back(std::move(bufferStorage));
        }

        memoryManager->StoreMemToAllocate(bufferStorageVec, backendAllocator, 4);
    }

    return memoryManager;
}

LayerBindingId LoadedNetwork::ValidateImportedInputID(ImportedInputId id)
{
    try
    {
        const auto& importedTensorHandlePin = m_PreImportedInputHandles.at(id);
        if (!importedTensorHandlePin.m_TensorHandle)
        {
            throw InvalidArgumentException(fmt::format(""LoadedNetwork::Execute:""
                                                       ""PreImportedInput: {} has been deleted"", id));
        }
        return importedTensorHandlePin.m_LayerBindingId;
    }
    catch (const std::out_of_range&)
    {
        throw InvalidArgumentException(fmt::format(""LoadedNetwork::Execute: Unknown ImportedInputId: {}"", id));
    }
}

LayerBindingId LoadedNetwork::ValidateImportedOutputID(ImportedOutputId id)
{
    try
    {
        const auto& importedTensorHandlePin = m_PreImportedOutputHandles.at(id);
        if (!importedTensorHandlePin.m_TensorHandle)
        {
            throw InvalidArgumentException(fmt::format(""LoadedNetwork::Execute: ""
                                                       ""PreImportedOutput: {} has been deleted"", id));
        }
        return importedTensorHandlePin.m_LayerBindingId;
    }
    catch (const std::out_of_range&)
    {
        throw InvalidArgumentException(fmt::format(""LoadedNetwork::Execute: Unknown ImportedOutputId: {}"", id));
    }
}

}
",16150,True,3114.420364391024,median
"/* ----------------------------------------------------------------------
   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
   http://lammps.sandia.gov, Sandia National Laboratories
   Steve Plimpton, sjplimp@sandia.gov

   Copyright (2003) Sandia Corporation.  Under the terms of Contract
   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
   certain rights in this software.  This software is distributed under
   the GNU General Public License.

   See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------
   Contributing author: Oliver Henrich (University of Strathclyde, Glasgow)
------------------------------------------------------------------------- */

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include ""pair_oxdna_hbond.h""
#include ""mf_oxdna.h""
#include ""atom.h""
#include ""comm.h""
#include ""force.h""
#include ""neighbor.h""
#include ""neigh_list.h""
#include ""neigh_request.h""
#include ""update.h""
#include ""integrate.h""
#include ""math_const.h""
#include ""memory.h""
#include ""error.h""
#include ""atom_vec_ellipsoid.h""
#include ""math_extra.h""

using namespace LAMMPS_NS;
using namespace MathConst;
using namespace MFOxdna;

// sequence-specific base-pairing strength
// A:0 C:1 G:2 T:3, 5'- (i,j) -3'
static const double alpha_hb[4][4] = 
{{1.00000,1.00000,1.00000,0.82915},
 {1.00000,1.00000,1.15413,1.00000},
 {1.00000,1.15413,1.00000,1.00000},
 {0.82915,1.00000,1.00000,1.00000}};

/* ---------------------------------------------------------------------- */

PairOxdnaHbond::PairOxdnaHbond(LAMMPS *lmp) : Pair(lmp)
{
  single_enable = 0;
  writedata = 1;
}

/* ---------------------------------------------------------------------- */

PairOxdnaHbond::~PairOxdnaHbond()
{
  if (allocated) {

    memory->destroy(setflag);
    memory->destroy(cutsq);

    memory->destroy(epsilon_hb);
    memory->destroy(a_hb);
    memory->destroy(cut_hb_0);
    memory->destroy(cut_hb_c);
    memory->destroy(cut_hb_lo);
    memory->destroy(cut_hb_hi);
    memory->destroy(cut_hb_lc);
    memory->destroy(cut_hb_hc);
    memory->destroy(cutsq_hb_hc);
    memory->destroy(b_hb_lo);
    memory->destroy(b_hb_hi);
    memory->destroy(shift_hb);

    memory->destroy(a_hb1);
    memory->destroy(theta_hb1_0);
    memory->destroy(dtheta_hb1_ast);
    memory->destroy(b_hb1);
    memory->destroy(dtheta_hb1_c);

    memory->destroy(a_hb2);
    memory->destroy(theta_hb2_0);
    memory->destroy(dtheta_hb2_ast);
    memory->destroy(b_hb2);
    memory->destroy(dtheta_hb2_c);

    memory->destroy(a_hb3);
    memory->destroy(theta_hb3_0);
    memory->destroy(dtheta_hb3_ast);
    memory->destroy(b_hb3);
    memory->destroy(dtheta_hb3_c);

    memory->destroy(a_hb4);
    memory->destroy(theta_hb4_0);
    memory->destroy(dtheta_hb4_ast);
    memory->destroy(b_hb4);
    memory->destroy(dtheta_hb4_c);

    memory->destroy(a_hb7);
    memory->destroy(theta_hb7_0);
    memory->destroy(dtheta_hb7_ast);
    memory->destroy(b_hb7);
    memory->destroy(dtheta_hb7_c);

    memory->destroy(a_hb8);
    memory->destroy(theta_hb8_0);
    memory->destroy(dtheta_hb8_ast);
    memory->destroy(b_hb8);
    memory->destroy(dtheta_hb8_c);

  }
}

/* ----------------------------------------------------------------------
   compute function for oxDNA pair interactions
   hb=hydrogen bonding site
------------------------------------------------------------------------- */

void PairOxdnaHbond::compute(int eflag, int vflag)
{

  double delf[3],delta[3],deltb[3]; // force, torque increment;
  double evdwl,fpair,finc,tpair,factor_lj;
  double delr_hb[3],delr_hb_norm[3],rsq_hb,r_hb,rinv_hb;
  double theta1,t1dir[3],cost1;
  double theta2,t2dir[3],cost2;
  double theta3,t3dir[3],cost3;
  double theta4,t4dir[3],cost4;
  double theta7,t7dir[3],cost7;
  double theta8,t8dir[3],cost8;

  // distance COM-hbonding site
  double d_chb=+0.4;
  // vectors COM-h-bonding site in lab frame
  double ra_chb[3],rb_chb[3];

  // quaternions and Cartesian unit vectors in lab frame
  double *qa,ax[3],ay[3],az[3];
  double *qb,bx[3],by[3],bz[3];

  double **x = atom->x;
  double **f = atom->f;
  double **torque = atom->torque;
  int *type = atom->type;

  int nlocal = atom->nlocal;
  int newton_pair = force->newton_pair;
  int *alist,*blist,*numneigh,**firstneigh;
  double *special_lj = force->special_lj;

  AtomVecEllipsoid *avec = (AtomVecEllipsoid *) atom->style_match(""ellipsoid"");
  AtomVecEllipsoid::Bonus *bonus = avec->bonus;

  int a,b,ia,ib,anum,bnum,atype,btype;

  double f1,f4t1,f4t4,f4t2,f4t3,f4t7,f4t8;
  double df1,df4t1,df4t4,df4t2,df4t3,df4t7,df4t8;

  evdwl = 0.0;
  ev_init(eflag,vflag);

  anum = list->inum;
  alist = list->ilist;
  numneigh = list->numneigh;
  firstneigh = list->firstneigh;

  // loop over pair interaction neighbors of my atoms

  for (ia = 0; ia < anum; ia++) {

    a = alist[ia];
    atype = type[a];

    qa=bonus[a].quat;
    MathExtra::q_to_exyz(qa,ax,ay,az);

    ra_chb[0] = d_chb*ax[0];
    ra_chb[1] = d_chb*ax[1];
    ra_chb[2] = d_chb*ax[2];

    blist = firstneigh[a];
    bnum = numneigh[a];

    for (ib = 0; ib < bnum; ib++) {

      b = blist[ib];
      factor_lj = special_lj[sbmask(b)]; // = 0 for nearest neighbors
      b &= NEIGHMASK;

      btype = type[b];

      qb=bonus[b].quat;
      MathExtra::q_to_exyz(qb,bx,by,bz);

      rb_chb[0] = d_chb*bx[0];
      rb_chb[1] = d_chb*bx[1];
      rb_chb[2] = d_chb*bx[2];

      // vector h-bonding site b to a
      delr_hb[0] = x[a][0] + ra_chb[0] - x[b][0] - rb_chb[0];
      delr_hb[1] = x[a][1] + ra_chb[1] - x[b][1] - rb_chb[1];
      delr_hb[2] = x[a][2] + ra_chb[2] - x[b][2] - rb_chb[2];

      rsq_hb = delr_hb[0]*delr_hb[0] + delr_hb[1]*delr_hb[1] + delr_hb[2]*delr_hb[2];
      r_hb = sqrt(rsq_hb);
      rinv_hb = 1.0/r_hb;

      delr_hb_norm[0] = delr_hb[0] * rinv_hb;
      delr_hb_norm[1] = delr_hb[1] * rinv_hb;
      delr_hb_norm[2] = delr_hb[2] * rinv_hb;

      f1 = F1(r_hb, epsilon_hb[atype][btype], a_hb[atype][btype], cut_hb_0[atype][btype],
            cut_hb_lc[atype][btype], cut_hb_hc[atype][btype], cut_hb_lo[atype][btype], cut_hb_hi[atype][btype],
            b_hb_lo[atype][btype], b_hb_hi[atype][btype], shift_hb[atype][btype]);

      // early rejection criterium
      if (f1) {

      cost1 = -1.0*MathExtra::dot3(ax,bx);
      if (cost1 >  1.0) cost1 =  1.0;
      if (cost1 < -1.0) cost1 = -1.0;
      theta1 = acos(cost1);

      f4t1 = F4(theta1, a_hb1[atype][btype], theta_hb1_0[atype][btype], dtheta_hb1_ast[atype][btype],
            b_hb1[atype][btype], dtheta_hb1_c[atype][btype]);

      // early rejection criterium
      if (f4t1) {

      cost2 = -1.0*MathExtra::dot3(ax,delr_hb_norm);
      if (cost2 >  1.0) cost2 =  1.0;
      if (cost2 < -1.0) cost2 = -1.0;
      theta2 = acos(cost2);

      f4t2 = F4(theta2, a_hb2[atype][btype], theta_hb2_0[atype][btype], dtheta_hb2_ast[atype][btype],
            b_hb2[atype][btype], dtheta_hb2_c[atype][btype]);

      // early rejection criterium
      if (f4t2) {

      cost3 = MathExtra::dot3(bx,delr_hb_norm);
      if (cost3 >  1.0) cost3 =  1.0;
      if (cost3 < -1.0) cost3 = -1.0;
      theta3 = acos(cost3);

      f4t3 = F4(theta3, a_hb3[atype][btype], theta_hb3_0[atype][btype], dtheta_hb3_ast[atype][btype],
            b_hb3[atype][btype], dtheta_hb3_c[atype][btype]);

      // early rejection criterium
      if (f4t3) {

      cost4 = MathExtra::dot3(az,bz);
      if (cost4 >  1.0) cost4 =  1.0;
      if (cost4 < -1.0) cost4 = -1.0;
      theta4 = acos(cost4);

      f4t4 = F4(theta4, a_hb4[atype][btype], theta_hb4_0[atype][btype], dtheta_hb4_ast[atype][btype],
            b_hb4[atype][btype], dtheta_hb4_c[atype][btype]);

      // early rejection criterium
      if (f4t4) {

      cost7 = -1.0*MathExtra::dot3(az,delr_hb_norm);
      if (cost7 >  1.0) cost7 =  1.0;
      if (cost7 < -1.0) cost7 = -1.0;
      theta7 = acos(cost7);

      f4t7 = F4(theta7, a_hb7[atype][btype], theta_hb7_0[atype][btype], dtheta_hb7_ast[atype][btype],
            b_hb7[atype][btype], dtheta_hb7_c[atype][btype]);

      // early rejection criterium
      if (f4t7) {

      cost8 = MathExtra::dot3(bz,delr_hb_norm);
      if (cost8 >  1.0) cost8 =  1.0;
      if (cost8 < -1.0) cost8 = -1.0;
      theta8 = acos(cost8);

      f4t8 = F4(theta8, a_hb8[atype][btype], theta_hb8_0[atype][btype], dtheta_hb8_ast[atype][btype],
            b_hb8[atype][btype], dtheta_hb8_c[atype][btype]);

      evdwl = f1 * f4t1 * f4t2 * f4t3 * f4t4 * f4t7 * f4t8 * factor_lj;

      // early rejection criterium
      if (evdwl) {

      df1 = DF1(r_hb, epsilon_hb[atype][btype], a_hb[atype][btype], cut_hb_0[atype][btype],
            cut_hb_lc[atype][btype], cut_hb_hc[atype][btype], cut_hb_lo[atype][btype], cut_hb_hi[atype][btype],
            b_hb_lo[atype][btype], b_hb_hi[atype][btype]);

      df4t1 = DF4(theta1, a_hb1[atype][btype], theta_hb1_0[atype][btype], dtheta_hb1_ast[atype][btype],
            b_hb1[atype][btype], dtheta_hb1_c[atype][btype])/sin(theta1);

      df4t2 = DF4(theta2, a_hb2[atype][btype], theta_hb2_0[atype][btype], dtheta_hb2_ast[atype][btype],
            b_hb2[atype][btype], dtheta_hb2_c[atype][btype])/sin(theta2);

      df4t3 = DF4(theta3, a_hb3[atype][btype], theta_hb3_0[atype][btype], dtheta_hb3_ast[atype][btype],
            b_hb3[atype][btype], dtheta_hb3_c[atype][btype])/sin(theta3);

      df4t4 = DF4(theta4, a_hb4[atype][btype], theta_hb4_0[atype][btype], dtheta_hb4_ast[atype][btype],
            b_hb4[atype][btype], dtheta_hb4_c[atype][btype])/sin(theta4);

      df4t7 = DF4(theta7, a_hb7[atype][btype], theta_hb7_0[atype][btype], dtheta_hb7_ast[atype][btype],
            b_hb7[atype][btype], dtheta_hb7_c[atype][btype])/sin(theta7);

      df4t8 = DF4(theta8, a_hb8[atype][btype], theta_hb8_0[atype][btype], dtheta_hb8_ast[atype][btype],
            b_hb8[atype][btype], dtheta_hb8_c[atype][btype])/sin(theta8);

      // force, torque and virial contribution for forces between h-bonding sites

      fpair = 0.0;

      delf[0] = 0.0;
      delf[1] = 0.0;
      delf[2] = 0.0;

      delta[0] = 0.0;
      delta[1] = 0.0;
      delta[2] = 0.0;

      deltb[0] = 0.0;
      deltb[1] = 0.0;
      deltb[2] = 0.0;

      // radial force
      finc  = -df1 * f4t1 * f4t2 * f4t3 * f4t4 * f4t7 * f4t8 * factor_lj;
      fpair += finc;

      delf[0] += delr_hb[0] * finc;
      delf[1] += delr_hb[1] * finc;
      delf[2] += delr_hb[2] * finc;

      // theta2 force
      if (theta2) {

        finc  = -f1 * f4t1 * df4t2 * f4t3 * f4t4 * f4t7 * f4t8 * rinv_hb * factor_lj;
        fpair += finc;

        delf[0] += (delr_hb_norm[0]*cost2 + ax[0]) * finc;
        delf[1] += (delr_hb_norm[1]*cost2 + ax[1]) * finc;
        delf[2] += (delr_hb_norm[2]*cost2 + ax[2]) * finc;

      }

      // theta3 force
      if (theta3) {

        finc  = -f1 * f4t1 * f4t2 * df4t3 * f4t4 * f4t7 * f4t8 * rinv_hb * factor_lj;
        fpair += finc;

        delf[0] += (delr_hb_norm[0]*cost3 - bx[0]) * finc;
        delf[1] += (delr_hb_norm[1]*cost3 - bx[1]) * finc;
        delf[2] += (delr_hb_norm[2]*cost3 - bx[2]) * finc;

      }

      // theta7 force
      if (theta7) {

        finc  = -f1 * f4t1 * f4t2 * f4t3 * f4t4 * df4t7 * f4t8 * rinv_hb * factor_lj;
        fpair += finc;

        delf[0] += (delr_hb_norm[0]*cost7 + az[0]) * finc;
        delf[1] += (delr_hb_norm[1]*cost7 + az[1]) * finc;
        delf[2] += (delr_hb_norm[2]*cost7 + az[2]) * finc;

      }

      // theta8 force
      if (theta8) {

        finc  = -f1 * f4t1 * f4t2 * f4t3 * f4t4 * f4t7 * df4t8 * rinv_hb * factor_lj;
        fpair += finc;

        delf[0] += (delr_hb_norm[0]*cost8 - bz[0]) * finc;
        delf[1] += (delr_hb_norm[1]*cost8 - bz[1]) * finc;
        delf[2] += (delr_hb_norm[2]*cost8 - bz[2]) * finc;

      }

      // increment forces and torques

      f[a][0] += delf[0];
      f[a][1] += delf[1];
      f[a][2] += delf[2];

      MathExtra::cross3(ra_chb,delf,delta);

      torque[a][0] += delta[0];
      torque[a][1] += delta[1];
      torque[a][2] += delta[2];

      if (newton_pair || b < nlocal) {

        f[b][0] -= delf[0];
        f[b][1] -= delf[1];
        f[b][2] -= delf[2];


        MathExtra::cross3(rb_chb,delf,deltb);

        torque[b][0] -= deltb[0];
        torque[b][1] -= deltb[1];
        torque[b][2] -= deltb[2];

      }

      // increment energy and virial
      // NOTE: The virial is calculated on the 'molecular' basis.
      // (see G. Ciccotti and J.P. Ryckaert, Comp. Phys. Rep. 4, 345-392 (1986))

      if (evflag) ev_tally_xyz(a,b,nlocal,newton_pair,evdwl,0.0,
          delf[0],delf[1],delf[2],x[a][0]-x[b][0],x[a][1]-x[b][1],x[a][2]-x[b][2]);

      // pure torques not expressible as r x f

      delta[0] = 0.0;
      delta[1] = 0.0;
      delta[2] = 0.0;
      deltb[0] = 0.0;
      deltb[1] = 0.0;
      deltb[2] = 0.0;

      // theta1 torque
      if (theta1) {

        tpair = -f1 * df4t1 * f4t2 * f4t3 * f4t4 * f4t7 * f4t8 * factor_lj;
        MathExtra::cross3(ax,bx,t1dir);

        delta[0] += t1dir[0]*tpair;
        delta[1] += t1dir[1]*tpair;
        delta[2] += t1dir[2]*tpair;

        deltb[0] += t1dir[0]*tpair;
        deltb[1] += t1dir[1]*tpair;
        deltb[2] += t1dir[2]*tpair;

      }

      // theta2 torque
      if (theta2) {

        tpair = -f1 * f4t1 * df4t2 * f4t3 * f4t4 * f4t7 * f4t8 * factor_lj;
        MathExtra::cross3(ax,delr_hb_norm,t2dir);

        delta[0] += t2dir[0]*tpair;
        delta[1] += t2dir[1]*tpair;
        delta[2] += t2dir[2]*tpair;

      }

      // theta3 torque
      if (theta3) {

        tpair = -f1 * f4t1 * f4t2 * df4t3 * f4t4 * f4t7 * f4t8 * factor_lj;
        MathExtra::cross3(bx,delr_hb_norm,t3dir);

        deltb[0] += t3dir[0]*tpair;
        deltb[1] += t3dir[1]*tpair;
        deltb[2] += t3dir[2]*tpair;

      }

      // theta4 torque
      if (theta4) {

        tpair = -f1 * f4t1 * f4t2 * f4t3 * df4t4 * f4t7 * f4t8 * factor_lj;
        MathExtra::cross3(bz,az,t4dir);

        delta[0] += t4dir[0]*tpair;
        delta[1] += t4dir[1]*tpair;
        delta[2] += t4dir[2]*tpair;

        deltb[0] += t4dir[0]*tpair;
        deltb[1] += t4dir[1]*tpair;
        deltb[2] += t4dir[2]*tpair;

      }

      // theta7 torque
      if (theta7) {

        tpair = -f1 * f4t1 * f4t2 * f4t3 * f4t4 * df4t7 * f4t8 * factor_lj;
        MathExtra::cross3(az,delr_hb_norm,t7dir);

        delta[0] += t7dir[0]*tpair;
        delta[1] += t7dir[1]*tpair;
        delta[2] += t7dir[2]*tpair;

      }

      // theta8 torque
      if (theta8) {

        tpair = -f1 * f4t1 * f4t2 * f4t3 * f4t4 * f4t7 * df4t8 * factor_lj;
        MathExtra::cross3(bz,delr_hb_norm,t8dir);

        deltb[0] += t8dir[0]*tpair;
        deltb[1] += t8dir[1]*tpair;
        deltb[2] += t8dir[2]*tpair;

      }

      // increment torques

      torque[a][0] += delta[0];
      torque[a][1] += delta[1];
      torque[a][2] += delta[2];

      if (newton_pair || b < nlocal) {

        torque[b][0] -= deltb[0];
        torque[b][1] -= deltb[1];
        torque[b][2] -= deltb[2];

      }

      }
      }
      }
      }
      }
      }
      }// end early rejection criteria

    }

  }

  if (vflag_fdotr) virial_fdotr_compute();
}

/* ----------------------------------------------------------------------
   allocate all arrays
------------------------------------------------------------------------- */

void PairOxdnaHbond::allocate()
{
  allocated = 1;
  int n = atom->ntypes;

  memory->create(setflag,n+1,n+1,""pair:setflag"");
  for (int i = 1; i <= n; i++)
    for (int j = i; j <= n; j++)
      setflag[i][j] = 0;

  memory->create(cutsq,n+1,n+1,""pair:cutsq"");

  memory->create(epsilon_hb,n+1,n+1,""pair:epsilon_hb"");
  memory->create(a_hb,n+1,n+1,""pair:a_hb"");
  memory->create(cut_hb_0,n+1,n+1,""pair:cut_hb_0"");
  memory->create(cut_hb_c,n+1,n+1,""pair:cut_hb_c"");
  memory->create(cut_hb_lo,n+1,n+1,""pair:cut_hb_lo"");
  memory->create(cut_hb_hi,n+1,n+1,""pair:cut_hb_hi"");
  memory->create(cut_hb_lc,n+1,n+1,""pair:cut_hb_lc"");
  memory->create(cut_hb_hc,n+1,n+1,""pair:cut_hb_hc"");
  memory->create(b_hb_lo,n+1,n+1,""pair:b_hb_lo"");
  memory->create(b_hb_hi,n+1,n+1,""pair:b_hb_hi"");
  memory->create(shift_hb,n+1,n+1,""pair:shift_hb"");
  memory->create(cutsq_hb_hc,n+1,n+1,""pair:cutsq_hb_hc"");

  memory->create(a_hb1,n+1,n+1,""pair:a_hb1"");
  memory->create(theta_hb1_0,n+1,n+1,""pair:theta_hb1_0"");
  memory->create(dtheta_hb1_ast,n+1,n+1,""pair:dtheta_hb1_ast"");
  memory->create(b_hb1,n+1,n+1,""pair:b_hb1"");
  memory->create(dtheta_hb1_c,n+1,n+1,""pair:dtheta_hb1_c"");

  memory->create(a_hb2,n+1,n+1,""pair:a_hb2"");
  memory->create(theta_hb2_0,n+1,n+1,""pair:theta_hb2_0"");
  memory->create(dtheta_hb2_ast,n+1,n+1,""pair:dtheta_hb2_ast"");
  memory->create(b_hb2,n+1,n+1,""pair:b_hb2"");
  memory->create(dtheta_hb2_c,n+1,n+1,""pair:dtheta_hb2_c"");

  memory->create(a_hb3,n+1,n+1,""pair:a_hb3"");
  memory->create(theta_hb3_0,n+1,n+1,""pair:theta_hb3_0"");
  memory->create(dtheta_hb3_ast,n+1,n+1,""pair:dtheta_hb3_ast"");
  memory->create(b_hb3,n+1,n+1,""pair:b_hb3"");
  memory->create(dtheta_hb3_c,n+1,n+1,""pair:dtheta_hb3_c"");

  memory->create(a_hb4,n+1,n+1,""pair:a_hb4"");
  memory->create(theta_hb4_0,n+1,n+1,""pair:theta_hb4_0"");
  memory->create(dtheta_hb4_ast,n+1,n+1,""pair:dtheta_hb4_ast"");
  memory->create(b_hb4,n+1,n+1,""pair:b_hb4"");
  memory->create(dtheta_hb4_c,n+1,n+1,""pair:dtheta_hb4_c"");

  memory->create(a_hb7,n+1,n+1,""pair:a_hb7"");
  memory->create(theta_hb7_0,n+1,n+1,""pair:theta_hb7_0"");
  memory->create(dtheta_hb7_ast,n+1,n+1,""pair:dtheta_hb7_ast"");
  memory->create(b_hb7,n+1,n+1,""pair:b_hb7"");
  memory->create(dtheta_hb7_c,n+1,n+1,""pair:dtheta_hb7_c"");

  memory->create(a_hb8,n+1,n+1,""pair:a_hb8"");
  memory->create(theta_hb8_0,n+1,n+1,""pair:theta_hb8_0"");
  memory->create(dtheta_hb8_ast,n+1,n+1,""pair:dtheta_hb8_ast"");
  memory->create(b_hb8,n+1,n+1,""pair:b_hb8"");
  memory->create(dtheta_hb8_c,n+1,n+1,""pair:dtheta_hb8_c"");

}

/* ----------------------------------------------------------------------
   global settings
------------------------------------------------------------------------- */

void PairOxdnaHbond::settings(int narg, char **/*arg*/)
{
  if (narg != 0) error->all(FLERR,""Illegal pair_style command"");

}

/* ----------------------------------------------------------------------
   set coeffs for one or more type pairs
------------------------------------------------------------------------- */

void PairOxdnaHbond::coeff(int narg, char **arg)
{
  int count;

  if (narg != 27) error->all(FLERR,""Incorrect args for pair coefficients in oxdna/hbond"");
  if (!allocated) allocate();

  int ilo,ihi,jlo,jhi;
  force->bounds(FLERR,arg[0],atom->ntypes,ilo,ihi);
  force->bounds(FLERR,arg[1],atom->ntypes,jlo,jhi);

  // h-bonding interaction
  count = 0;

  double epsilon_hb_one, a_hb_one, cut_hb_0_one, cut_hb_c_one, cut_hb_lo_one, cut_hb_hi_one;
  double b_hb_lo_one, b_hb_hi_one, cut_hb_lc_one, cut_hb_hc_one, tmp, shift_hb_one;

  double a_hb1_one, theta_hb1_0_one, dtheta_hb1_ast_one;
  double b_hb1_one, dtheta_hb1_c_one;

  double a_hb2_one, theta_hb2_0_one, dtheta_hb2_ast_one;
  double b_hb2_one, dtheta_hb2_c_one;

  double a_hb3_one, theta_hb3_0_one, dtheta_hb3_ast_one;
  double b_hb3_one, dtheta_hb3_c_one;

  double a_hb4_one, theta_hb4_0_one, dtheta_hb4_ast_one;
  double b_hb4_one, dtheta_hb4_c_one;

  double a_hb7_one, theta_hb7_0_one, dtheta_hb7_ast_one;
  double b_hb7_one, dtheta_hb7_c_one;

  double a_hb8_one, theta_hb8_0_one, dtheta_hb8_ast_one;
  double b_hb8_one, dtheta_hb8_c_one;

  if (strcmp(arg[2], ""seqav"") != 0 && strcmp(arg[2], ""seqdep"") != 0) {
    error->all(FLERR,""Incorrect setting, select seqav or seqdep in oxdna/hbond"");
  }
  if (strcmp(arg[2],""seqav"")  == 0) seqdepflag = 0;
  if (strcmp(arg[2],""seqdep"") == 0) seqdepflag = 1;

  epsilon_hb_one = force->numeric(FLERR,arg[3]);
  a_hb_one = force->numeric(FLERR,arg[4]);
  cut_hb_0_one = force->numeric(FLERR,arg[5]);
  cut_hb_c_one = force->numeric(FLERR,arg[6]);
  cut_hb_lo_one = force->numeric(FLERR,arg[7]);
  cut_hb_hi_one = force->numeric(FLERR,arg[8]);

  a_hb1_one = force->numeric(FLERR,arg[9]);
  theta_hb1_0_one = force->numeric(FLERR,arg[10]);
  dtheta_hb1_ast_one = force->numeric(FLERR,arg[11]);

  a_hb2_one = force->numeric(FLERR,arg[12]);
  theta_hb2_0_one = force->numeric(FLERR,arg[13]);
  dtheta_hb2_ast_one = force->numeric(FLERR,arg[14]);

  a_hb3_one = force->numeric(FLERR,arg[15]);
  theta_hb3_0_one = force->numeric(FLERR,arg[16]);
  dtheta_hb3_ast_one = force->numeric(FLERR,arg[17]);

  a_hb4_one = force->numeric(FLERR,arg[18]);
  theta_hb4_0_one = force->numeric(FLERR,arg[19]);
  dtheta_hb4_ast_one = force->numeric(FLERR,arg[20]);

  a_hb7_one = force->numeric(FLERR,arg[21]);
  theta_hb7_0_one = force->numeric(FLERR,arg[22]);
  dtheta_hb7_ast_one = force->numeric(FLERR,arg[23]);

  a_hb8_one = force->numeric(FLERR,arg[24]);
  theta_hb8_0_one = force->numeric(FLERR,arg[25]);
  dtheta_hb8_ast_one = force->numeric(FLERR,arg[26]);

  b_hb_lo_one = 2*a_hb_one*exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one))*
        2*a_hb_one*exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one))*
        (1-exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one)))*
        (1-exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one)))/
        (4*((1-exp(-a_hb_one*(cut_hb_lo_one -cut_hb_0_one)))*
        (1-exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one)))-
        (1-exp(-a_hb_one*(cut_hb_c_one -cut_hb_0_one)))*
        (1-exp(-a_hb_one*(cut_hb_c_one-cut_hb_0_one)))));

  cut_hb_lc_one = cut_hb_lo_one - a_hb_one*exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one))*
        (1-exp(-a_hb_one*(cut_hb_lo_one-cut_hb_0_one)))/b_hb_lo_one;

  b_hb_hi_one = 2*a_hb_one*exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one))*
        2*a_hb_one*exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one))*
        (1-exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one)))*
        (1-exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one)))/
        (4*((1-exp(-a_hb_one*(cut_hb_hi_one -cut_hb_0_one)))*
        (1-exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one)))-
        (1-exp(-a_hb_one*(cut_hb_c_one -cut_hb_0_one)))*
        (1-exp(-a_hb_one*(cut_hb_c_one-cut_hb_0_one)))));

  cut_hb_hc_one = cut_hb_hi_one - a_hb_one*exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one))*
        (1-exp(-a_hb_one*(cut_hb_hi_one-cut_hb_0_one)))/b_hb_hi_one;

  tmp = 1 - exp(-(cut_hb_c_one-cut_hb_0_one) * a_hb_one);
  shift_hb_one = epsilon_hb_one * tmp * tmp;

  b_hb1_one = a_hb1_one*a_hb1_one*dtheta_hb1_ast_one*dtheta_hb1_ast_one/(1-a_hb1_one*dtheta_hb1_ast_one*dtheta_hb1_ast_one);
  dtheta_hb1_c_one = 1/(a_hb1_one*dtheta_hb1_ast_one);

  b_hb2_one = a_hb2_one*a_hb2_one*dtheta_hb2_ast_one*dtheta_hb2_ast_one/(1-a_hb2_one*dtheta_hb2_ast_one*dtheta_hb2_ast_one);
  dtheta_hb2_c_one = 1/(a_hb2_one*dtheta_hb2_ast_one);

  b_hb3_one = a_hb3_one*a_hb3_one*dtheta_hb3_ast_one*dtheta_hb3_ast_one/(1-a_hb3_one*dtheta_hb3_ast_one*dtheta_hb3_ast_one);
  dtheta_hb3_c_one = 1/(a_hb3_one*dtheta_hb3_ast_one);

  b_hb4_one = a_hb4_one*a_hb4_one*dtheta_hb4_ast_one*dtheta_hb4_ast_one/(1-a_hb4_one*dtheta_hb4_ast_one*dtheta_hb4_ast_one);
  dtheta_hb4_c_one = 1/(a_hb4_one*dtheta_hb4_ast_one);

  b_hb7_one = a_hb7_one*a_hb7_one*dtheta_hb7_ast_one*dtheta_hb7_ast_one/(1-a_hb7_one*dtheta_hb7_ast_one*dtheta_hb7_ast_one);
  dtheta_hb7_c_one = 1/(a_hb7_one*dtheta_hb7_ast_one);

  b_hb8_one = a_hb8_one*a_hb8_one*dtheta_hb8_ast_one*dtheta_hb8_ast_one/(1-a_hb8_one*dtheta_hb8_ast_one*dtheta_hb8_ast_one);
  dtheta_hb8_c_one = 1/(a_hb8_one*dtheta_hb8_ast_one);

  for (int i = ilo; i <= ihi; i++) {
    for (int j = MAX(jlo,i); j <= jhi; j++) {

      epsilon_hb[i][j] = epsilon_hb_one;
      if (seqdepflag) epsilon_hb[i][j] *= alpha_hb[i-1][j-1];
      a_hb[i][j] = a_hb_one;
      cut_hb_0[i][j] = cut_hb_0_one;
      cut_hb_c[i][j] = cut_hb_c_one;
      cut_hb_lo[i][j] = cut_hb_lo_one;
      cut_hb_hi[i][j] = cut_hb_hi_one;
      cut_hb_lc[i][j] = cut_hb_lc_one;
      cut_hb_hc[i][j] = cut_hb_hc_one;
      b_hb_lo[i][j] = b_hb_lo_one;
      b_hb_hi[i][j] = b_hb_hi_one;
      shift_hb[i][j] = shift_hb_one;
      if (seqdepflag) shift_hb[i][j] *= alpha_hb[i-1][j-1];

      a_hb1[i][j] = a_hb1_one;
      theta_hb1_0[i][j] = theta_hb1_0_one;
      dtheta_hb1_ast[i][j] = dtheta_hb1_ast_one;
      b_hb1[i][j] = b_hb1_one;
      dtheta_hb1_c[i][j] = dtheta_hb1_c_one;

      a_hb2[i][j] = a_hb2_one;
      theta_hb2_0[i][j] = theta_hb2_0_one;
      dtheta_hb2_ast[i][j] = dtheta_hb2_ast_one;
      b_hb2[i][j] = b_hb2_one;
      dtheta_hb2_c[i][j] = dtheta_hb2_c_one;

      a_hb3[i][j] = a_hb3_one;
      theta_hb3_0[i][j] = theta_hb3_0_one;
      dtheta_hb3_ast[i][j] = dtheta_hb3_ast_one;
      b_hb3[i][j] = b_hb3_one;
      dtheta_hb3_c[i][j] = dtheta_hb3_c_one;

      a_hb4[i][j] = a_hb4_one;
      theta_hb4_0[i][j] = theta_hb4_0_one;
      dtheta_hb4_ast[i][j] = dtheta_hb4_ast_one;
      b_hb4[i][j] = b_hb4_one;
      dtheta_hb4_c[i][j] = dtheta_hb4_c_one;

      a_hb7[i][j] = a_hb7_one;
      theta_hb7_0[i][j] = theta_hb7_0_one;
      dtheta_hb7_ast[i][j] = dtheta_hb7_ast_one;
      b_hb7[i][j] = b_hb7_one;
      dtheta_hb7_c[i][j] = dtheta_hb7_c_one;

      a_hb8[i][j] = a_hb8_one;
      theta_hb8_0[i][j] = theta_hb8_0_one;
      dtheta_hb8_ast[i][j] = dtheta_hb8_ast_one;
      b_hb8[i][j] = b_hb8_one;
      dtheta_hb8_c[i][j] = dtheta_hb8_c_one;

      setflag[i][j] = 1;
      count++;
    }
  }

  if (count == 0) error->all(FLERR,""Incorrect args for pair coefficients in oxdna/hbond"");

}

/* ----------------------------------------------------------------------
   init specific to this pair style
------------------------------------------------------------------------- */

void PairOxdnaHbond::init_style()
{
  int irequest;

  // request regular neighbor lists

  irequest = neighbor->request(this,instance_me);

}

/* ----------------------------------------------------------------------
   neighbor callback to inform pair style of neighbor list to use regular
------------------------------------------------------------------------- */

void PairOxdnaHbond::init_list(int id, NeighList *ptr)
{
  if (id == 0) list = ptr;
  if (id  > 0) error->all(FLERR,""Respa not supported"");

}


/* ----------------------------------------------------------------------
   init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */

double PairOxdnaHbond::init_one(int i, int j)
{

  if (setflag[i][j] == 0) {
    error->all(FLERR,""Coefficient mixing not defined in oxDNA"");
  }
  if (offset_flag) {
    error->all(FLERR,""Offset not supported in oxDNA"");
  }

  if (seqdepflag) {
    epsilon_hb[j][i] = epsilon_hb[i][j] / alpha_hb[i-1][j-1] * alpha_hb[j-1][i-1];
  }
  else {
    epsilon_hb[j][i] = epsilon_hb[i][j];
  }
  a_hb[j][i] = a_hb[i][j];
  cut_hb_0[j][i] = cut_hb_0[i][j];
  cut_hb_c[j][i] = cut_hb_c[i][j];
  cut_hb_lo[j][i] = cut_hb_lo[i][j];
  cut_hb_hi[j][i] = cut_hb_hi[i][j];
  b_hb_lo[j][i] = b_hb_lo[i][j];
  b_hb_hi[j][i] = b_hb_hi[i][j];
  cut_hb_lc[j][i] = cut_hb_lc[i][j];
  cut_hb_hc[j][i] = cut_hb_hc[i][j];
  if (seqdepflag) {
    shift_hb[j][i] = shift_hb[i][j] / alpha_hb[i-1][j-1] * alpha_hb[j-1][i-1];
  }
  else {
    shift_hb[j][i] = shift_hb[i][j];
  }

  a_hb1[j][i] = a_hb1[i][j];
  theta_hb1_0[j][i] = theta_hb1_0[i][j];
  dtheta_hb1_ast[j][i] = dtheta_hb1_ast[i][j];
  b_hb1[j][i] = b_hb1[i][j];
  dtheta_hb1_c[j][i] = dtheta_hb1_c[i][j];

  a_hb2[j][i] = a_hb2[i][j];
  theta_hb2_0[j][i] = theta_hb2_0[i][j];
  dtheta_hb2_ast[j][i] = dtheta_hb2_ast[i][j];
  b_hb2[j][i] = b_hb2[i][j];
  dtheta_hb2_c[j][i] = dtheta_hb2_c[i][j];

  a_hb3[j][i] = a_hb3[i][j];
  theta_hb3_0[j][i] = theta_hb3_0[i][j];
  dtheta_hb3_ast[j][i] = dtheta_hb3_ast[i][j];
  b_hb3[j][i] = b_hb3[i][j];
  dtheta_hb3_c[j][i] = dtheta_hb3_c[i][j];

  a_hb4[j][i] = a_hb4[i][j];
  theta_hb4_0[j][i] = theta_hb4_0[i][j];
  dtheta_hb4_ast[j][i] = dtheta_hb4_ast[i][j];
  b_hb4[j][i] = b_hb4[i][j];
  dtheta_hb4_c[j][i] = dtheta_hb4_c[i][j];

  a_hb7[j][i] = a_hb7[i][j];
  theta_hb7_0[j][i] = theta_hb7_0[i][j];
  dtheta_hb7_ast[j][i] = dtheta_hb7_ast[i][j];
  b_hb7[j][i] = b_hb7[i][j];
  dtheta_hb7_c[j][i] = dtheta_hb7_c[i][j];

  a_hb8[j][i] = a_hb8[i][j];
  theta_hb8_0[j][i] = theta_hb8_0[i][j];
  dtheta_hb8_ast[j][i] = dtheta_hb8_ast[i][j];
  b_hb8[j][i] = b_hb8[i][j];
  dtheta_hb8_c[j][i] = dtheta_hb8_c[i][j];

  cutsq_hb_hc[i][j] = cut_hb_hc[i][j]*cut_hb_hc[i][j];
  cutsq_hb_hc[j][i] = cutsq_hb_hc[i][j];

  // set the master list distance cutoff
  return cut_hb_hc[i][j];

}

/* ----------------------------------------------------------------------
   proc 0 writes to restart file
------------------------------------------------------------------------- */

void PairOxdnaHbond::write_restart(FILE *fp)
{
  write_restart_settings(fp);

  int i,j;
  for (i = 1; i <= atom->ntypes; i++)
    for (j = i; j <= atom->ntypes; j++) {
      fwrite(&setflag[i][j],sizeof(int),1,fp);
      if (setflag[i][j]) {

        fwrite(&epsilon_hb[i][j],sizeof(double),1,fp);
        fwrite(&a_hb[i][j],sizeof(double),1,fp);
        fwrite(&cut_hb_0[i][j],sizeof(double),1,fp);
        fwrite(&cut_hb_c[i][j],sizeof(double),1,fp);
        fwrite(&cut_hb_lo[i][j],sizeof(double),1,fp);
        fwrite(&cut_hb_hi[i][j],sizeof(double),1,fp);
        fwrite(&cut_hb_lc[i][j],sizeof(double),1,fp);
        fwrite(&cut_hb_hc[i][j],sizeof(double),1,fp);
        fwrite(&b_hb_lo[i][j],sizeof(double),1,fp);
        fwrite(&b_hb_hi[i][j],sizeof(double),1,fp);
        fwrite(&shift_hb[i][j],sizeof(double),1,fp);

        fwrite(&a_hb1[i][j],sizeof(double),1,fp);
        fwrite(&theta_hb1_0[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb1_ast[i][j],sizeof(double),1,fp);
        fwrite(&b_hb1[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb1_c[i][j],sizeof(double),1,fp);

        fwrite(&a_hb2[i][j],sizeof(double),1,fp);
        fwrite(&theta_hb2_0[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb2_ast[i][j],sizeof(double),1,fp);
        fwrite(&b_hb2[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb2_c[i][j],sizeof(double),1,fp);

        fwrite(&a_hb3[i][j],sizeof(double),1,fp);
        fwrite(&theta_hb3_0[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb3_ast[i][j],sizeof(double),1,fp);
        fwrite(&b_hb3[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb3_c[i][j],sizeof(double),1,fp);

        fwrite(&a_hb4[i][j],sizeof(double),1,fp);
        fwrite(&theta_hb4_0[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb4_ast[i][j],sizeof(double),1,fp);
        fwrite(&b_hb4[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb4_c[i][j],sizeof(double),1,fp);

        fwrite(&a_hb7[i][j],sizeof(double),1,fp);
        fwrite(&theta_hb7_0[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb7_ast[i][j],sizeof(double),1,fp);
        fwrite(&b_hb7[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb7_c[i][j],sizeof(double),1,fp);

        fwrite(&a_hb8[i][j],sizeof(double),1,fp);
        fwrite(&theta_hb8_0[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb8_ast[i][j],sizeof(double),1,fp);
        fwrite(&b_hb8[i][j],sizeof(double),1,fp);
        fwrite(&dtheta_hb8_c[i][j],sizeof(double),1,fp);

    }
  }
}

/* ----------------------------------------------------------------------
   proc 0 reads from restart file, bcasts
------------------------------------------------------------------------- */

void PairOxdnaHbond::read_restart(FILE *fp)
{
  read_restart_settings(fp);
  allocate();

  int i,j;
  int me = comm->me;
  for (i = 1; i <= atom->ntypes; i++)
    for (j = i; j <= atom->ntypes; j++) {
      if (me == 0) fread(&setflag[i][j],sizeof(int),1,fp);
      MPI_Bcast(&setflag[i][j],1,MPI_INT,0,world);
      if (setflag[i][j]) {
        if (me == 0) {

          fread(&epsilon_hb[i][j],sizeof(double),1,fp);
          fread(&a_hb[i][j],sizeof(double),1,fp);
          fread(&cut_hb_0[i][j],sizeof(double),1,fp);
          fread(&cut_hb_c[i][j],sizeof(double),1,fp);
          fread(&cut_hb_lo[i][j],sizeof(double),1,fp);
          fread(&cut_hb_hi[i][j],sizeof(double),1,fp);
          fread(&cut_hb_lc[i][j],sizeof(double),1,fp);
          fread(&cut_hb_hc[i][j],sizeof(double),1,fp);
          fread(&b_hb_lo[i][j],sizeof(double),1,fp);
          fread(&b_hb_hi[i][j],sizeof(double),1,fp);
          fread(&shift_hb[i][j],sizeof(double),1,fp);

          fread(&a_hb1[i][j],sizeof(double),1,fp);
          fread(&theta_hb1_0[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb1_ast[i][j],sizeof(double),1,fp);
          fread(&b_hb1[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb1_c[i][j],sizeof(double),1,fp);

          fread(&a_hb2[i][j],sizeof(double),1,fp);
          fread(&theta_hb2_0[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb2_ast[i][j],sizeof(double),1,fp);
          fread(&b_hb2[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb2_c[i][j],sizeof(double),1,fp);

          fread(&a_hb3[i][j],sizeof(double),1,fp);
          fread(&theta_hb3_0[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb3_ast[i][j],sizeof(double),1,fp);
          fread(&b_hb3[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb3_c[i][j],sizeof(double),1,fp);

          fread(&a_hb4[i][j],sizeof(double),1,fp);
          fread(&theta_hb4_0[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb4_ast[i][j],sizeof(double),1,fp);
          fread(&b_hb4[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb4_c[i][j],sizeof(double),1,fp);

          fread(&a_hb7[i][j],sizeof(double),1,fp);
          fread(&theta_hb7_0[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb7_ast[i][j],sizeof(double),1,fp);
          fread(&b_hb7[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb7_c[i][j],sizeof(double),1,fp);

          fread(&a_hb8[i][j],sizeof(double),1,fp);
          fread(&theta_hb8_0[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb8_ast[i][j],sizeof(double),1,fp);
          fread(&b_hb8[i][j],sizeof(double),1,fp);
          fread(&dtheta_hb8_c[i][j],sizeof(double),1,fp);

        }

        MPI_Bcast(&epsilon_hb[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&a_hb[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&cut_hb_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&cut_hb_c[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&cut_hb_lo[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&cut_hb_hi[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&cut_hb_lc[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&cut_hb_hc[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb_lo[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb_hi[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&shift_hb[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&a_hb1[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&theta_hb1_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb1_ast[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb1[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb1_c[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&a_hb2[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&theta_hb2_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb2_ast[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb2[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb2_c[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&a_hb3[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&theta_hb3_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb3_ast[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb3[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb3_c[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&a_hb4[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&theta_hb4_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb4_ast[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb4[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb4_c[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&a_hb7[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&theta_hb7_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb7_ast[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb7[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb7_c[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&a_hb8[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&theta_hb8_0[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb8_ast[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&b_hb8[i][j],1,MPI_DOUBLE,0,world);
        MPI_Bcast(&dtheta_hb8_c[i][j],1,MPI_DOUBLE,0,world);

      }
    }
}

/* ----------------------------------------------------------------------
   proc 0 writes to restart file
------------------------------------------------------------------------- */

void PairOxdnaHbond::write_restart_settings(FILE *fp)
{
  fwrite(&offset_flag,sizeof(int),1,fp);
  fwrite(&mix_flag,sizeof(int),1,fp);
  fwrite(&tail_flag,sizeof(int),1,fp);
}

/* ----------------------------------------------------------------------
   proc 0 reads from restart file, bcasts
------------------------------------------------------------------------- */

void PairOxdnaHbond::read_restart_settings(FILE *fp)
{
  int me = comm->me;
  if (me == 0) {
    fread(&offset_flag,sizeof(int),1,fp);
    fread(&mix_flag,sizeof(int),1,fp);
    fread(&tail_flag,sizeof(int),1,fp);
  }
  MPI_Bcast(&offset_flag,1,MPI_INT,0,world);
  MPI_Bcast(&mix_flag,1,MPI_INT,0,world);
  MPI_Bcast(&tail_flag,1,MPI_INT,0,world);
}

/* ----------------------------------------------------------------------
   proc 0 writes to data file
------------------------------------------------------------------------- */

void PairOxdnaHbond::write_data(FILE *fp)
{
  for (int i = 1; i <= atom->ntypes; i++)
    fprintf(fp,""%d\\
         %g %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         \\n"",i,
        epsilon_hb[i][i],a_hb[i][i],cut_hb_0[i][i],cut_hb_c[i][i],cut_hb_lo[i][i],cut_hb_hi[i][i],
        cut_hb_lc[i][i],cut_hb_hc[i][i],b_hb_lo[i][i],b_hb_hi[i][i],shift_hb[i][i],
        a_hb1[i][i],theta_hb1_0[i][i],dtheta_hb1_ast[i][i],b_hb1[i][i],dtheta_hb1_c[i][i],
        a_hb2[i][i],theta_hb2_0[i][i],dtheta_hb2_ast[i][i],b_hb2[i][i],dtheta_hb2_c[i][i],
        a_hb3[i][i],theta_hb3_0[i][i],dtheta_hb3_ast[i][i],b_hb3[i][i],dtheta_hb3_c[i][i],
        a_hb4[i][i],theta_hb4_0[i][i],dtheta_hb4_ast[i][i],b_hb4[i][i],dtheta_hb4_c[i][i],
        a_hb7[i][i],theta_hb7_0[i][i],dtheta_hb7_ast[i][i],b_hb7[i][i],dtheta_hb7_c[i][i],
        a_hb8[i][i],theta_hb8_0[i][i],dtheta_hb8_ast[i][i],b_hb8[i][i],dtheta_hb8_c[i][i]);

}

/* ----------------------------------------------------------------------
   proc 0 writes all pairs to data file
------------------------------------------------------------------------- */

void PairOxdnaHbond::write_data_all(FILE *fp)
{
  for (int i = 1; i <= atom->ntypes; i++)
    for (int j = i; j <= atom->ntypes; j++)
      fprintf(fp,""%d %d\\
         %g %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         %g %g %g %g %g\\
         \\n"",i,j,
        epsilon_hb[i][j],a_hb[i][j],cut_hb_0[i][j],cut_hb_c[i][j],cut_hb_lo[i][j],cut_hb_hi[i][j],
        cut_hb_lc[i][j],cut_hb_hc[i][j],b_hb_lo[i][j],b_hb_hi[i][j],shift_hb[i][j],
        a_hb1[i][j],theta_hb1_0[i][j],dtheta_hb1_ast[i][j],b_hb1[i][j],dtheta_hb1_c[i][j],
        a_hb2[i][j],theta_hb2_0[i][j],dtheta_hb2_ast[i][j],b_hb2[i][j],dtheta_hb2_c[i][j],
        a_hb3[i][j],theta_hb3_0[i][j],dtheta_hb3_ast[i][j],b_hb3[i][j],dtheta_hb3_c[i][j],
        a_hb4[i][j],theta_hb4_0[i][j],dtheta_hb4_ast[i][j],b_hb4[i][j],dtheta_hb4_c[i][j],
        a_hb7[i][j],theta_hb7_0[i][j],dtheta_hb7_ast[i][j],b_hb7[i][j],dtheta_hb7_c[i][j],
        a_hb8[i][j],theta_hb8_0[i][j],dtheta_hb8_ast[i][j],b_hb8[i][j],dtheta_hb8_c[i][j]);

}

/* ---------------------------------------------------------------------- */

void *PairOxdnaHbond::extract(const char *str, int &dim)
{
  dim = 2;

  if (strcmp(str,""epsilon_hb"") == 0) return (void *) epsilon_hb;
  if (strcmp(str,""a_hb"") == 0) return (void *) a_hb;
  if (strcmp(str,""cut_hb_0"") == 0) return (void *) cut_hb_0;
  if (strcmp(str,""cut_hb_c"") == 0) return (void *) cut_hb_c;
  if (strcmp(str,""cut_hb_lo"") == 0) return (void *) cut_hb_lo;
  if (strcmp(str,""cut_hb_hi"") == 0) return (void *) cut_hb_hi;
  if (strcmp(str,""cut_hb_lc"") == 0) return (void *) cut_hb_lc;
  if (strcmp(str,""cut_hb_hc"") == 0) return (void *) cut_hb_hc;
  if (strcmp(str,""b_hb_lo"") == 0) return (void *) b_hb_lo;
  if (strcmp(str,""b_hb_hi"") == 0) return (void *) b_hb_hi;
  if (strcmp(str,""shift_hb"") == 0) return (void *) shift_hb;

  if (strcmp(str,""a_hb1"") == 0) return (void *) a_hb1;
  if (strcmp(str,""theta_hb1_0"") == 0) return (void *) theta_hb1_0;
  if (strcmp(str,""dtheta_hb1_ast"") == 0) return (void *) dtheta_hb1_ast;
  if (strcmp(str,""b_hb1"") == 0) return (void *) b_hb1;
  if (strcmp(str,""dtheta_hb1_c"") == 0) return (void *) dtheta_hb1_c;

  if (strcmp(str,""a_hb2"") == 0) return (void *) a_hb2;
  if (strcmp(str,""theta_hb2_0"") == 0) return (void *) theta_hb2_0;
  if (strcmp(str,""dtheta_hb2_ast"") == 0) return (void *) dtheta_hb2_ast;
  if (strcmp(str,""b_hb2"") == 0) return (void *) b_hb2;
  if (strcmp(str,""dtheta_hb2_c"") == 0) return (void *) dtheta_hb2_c;

  if (strcmp(str,""a_hb3"") == 0) return (void *) a_hb3;
  if (strcmp(str,""theta_hb3_0"") == 0) return (void *) theta_hb3_0;
  if (strcmp(str,""dtheta_hb3_ast"") == 0) return (void *) dtheta_hb3_ast;
  if (strcmp(str,""b_hb3"") == 0) return (void *) b_hb3;
  if (strcmp(str,""dtheta_hb3_c"") == 0) return (void *) dtheta_hb3_c;

  if (strcmp(str,""a_hb4"") == 0) return (void *) a_hb4;
  if (strcmp(str,""theta_hb4_0"") == 0) return (void *) theta_hb4_0;
  if (strcmp(str,""dtheta_hb4_ast"") == 0) return (void *) dtheta_hb4_ast;
  if (strcmp(str,""b_hb4"") == 0) return (void *) b_hb4;
  if (strcmp(str,""dtheta_hb4_c"") == 0) return (void *) dtheta_hb4_c;

  if (strcmp(str,""a_hb7"") == 0) return (void *) a_hb7;
  if (strcmp(str,""theta_hb7_0"") == 0) return (void *) theta_hb7_0;
  if (strcmp(str,""dtheta_hb7_ast"") == 0) return (void *) dtheta_hb7_ast;
  if (strcmp(str,""b_hb7"") == 0) return (void *) b_hb7;
  if (strcmp(str,""dtheta_hb7_c"") == 0) return (void *) dtheta_hb7_c;

  if (strcmp(str,""a_hb8"") == 0) return (void *) a_hb8;
  if (strcmp(str,""theta_hb8_0"") == 0) return (void *) theta_hb8_0;
  if (strcmp(str,""dtheta_hb8_ast"") == 0) return (void *) dtheta_hb8_ast;
  if (strcmp(str,""b_hb8"") == 0) return (void *) b_hb8;
  if (strcmp(str,""dtheta_hb8_c"") == 0) return (void *) dtheta_hb8_c;

  return NULL;
}
",16234,True,3215.541365504242,median
"#include ""il2cpp-config.h""

#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif


#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>

#include ""il2cpp-class-internals.h""
#include ""codegen/il2cpp-codegen.h""
#include ""il2cpp-object-internals.h""

template <typename T1, typename T2, typename T3, typename T4>
struct VirtActionInvoker4
{
	typedef void (*Action)(void*, T1, T2, T3, T4, const RuntimeMethod*);

	static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
		((Action)invokeData.methodPtr)(obj, p1, p2, p3, p4, invokeData.method);
	}
};
struct VirtActionInvoker0
{
	typedef void (*Action)(void*, const RuntimeMethod*);

	static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
	{
		const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
		((Action)invokeData.methodPtr)(obj, invokeData.method);
	}
};
template <typename T1, typename T2, typename T3, typename T4>
struct GenericVirtActionInvoker4
{
	typedef void (*Action)(void*, T1, T2, T3, T4, const RuntimeMethod*);

	static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		VirtualInvokeData invokeData;
		il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
		((Action)invokeData.methodPtr)(obj, p1, p2, p3, p4, invokeData.method);
	}
};
struct GenericVirtActionInvoker0
{
	typedef void (*Action)(void*, const RuntimeMethod*);

	static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj)
	{
		VirtualInvokeData invokeData;
		il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
		((Action)invokeData.methodPtr)(obj, invokeData.method);
	}
};
template <typename T1, typename T2, typename T3, typename T4>
struct InterfaceActionInvoker4
{
	typedef void (*Action)(void*, T1, T2, T3, T4, const RuntimeMethod*);

	static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
		((Action)invokeData.methodPtr)(obj, p1, p2, p3, p4, invokeData.method);
	}
};
struct InterfaceActionInvoker0
{
	typedef void (*Action)(void*, const RuntimeMethod*);

	static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj)
	{
		const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
		((Action)invokeData.methodPtr)(obj, invokeData.method);
	}
};
template <typename T1, typename T2, typename T3, typename T4>
struct GenericInterfaceActionInvoker4
{
	typedef void (*Action)(void*, T1, T2, T3, T4, const RuntimeMethod*);

	static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		VirtualInvokeData invokeData;
		il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
		((Action)invokeData.methodPtr)(obj, p1, p2, p3, p4, invokeData.method);
	}
};
struct GenericInterfaceActionInvoker0
{
	typedef void (*Action)(void*, const RuntimeMethod*);

	static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj)
	{
		VirtualInvokeData invokeData;
		il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
		((Action)invokeData.methodPtr)(obj, invokeData.method);
	}
};

// System.Action
struct Action_t1264377477;
// System.Action`1<System.Boolean>
struct Action_1_t269755560;
// System.Action`3<System.Boolean,System.Boolean,System.Int32>
struct Action_3_t3050575418;
// System.AsyncCallback
struct AsyncCallback_t3962456242;
// System.Char[]
struct CharU5BU5D_t3528271667;
// System.DelegateData
struct DelegateData_t1677132599;
// System.IAsyncResult
struct IAsyncResult_t767004451;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.String
struct String_t;
// System.Void
struct Void_t1185182177;
// UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged
struct SessionStateChanged_t3163629820;
// UnityEngine.RemoteConfigSettings
struct RemoteConfigSettings_t1247263429;
// UnityEngine.RemoteSettings/UpdatedEventHandler
struct UpdatedEventHandler_t1027848393;

extern RuntimeClass* Action_1_t269755560_il2cpp_TypeInfo_var;
extern RuntimeClass* AnalyticsSessionInfo_t2322308579_il2cpp_TypeInfo_var;
extern RuntimeClass* AnalyticsSessionState_t681173134_il2cpp_TypeInfo_var;
extern RuntimeClass* Boolean_t97287965_il2cpp_TypeInfo_var;
extern RuntimeClass* Int64_t3736567304_il2cpp_TypeInfo_var;
extern RuntimeClass* IntPtr_t_il2cpp_TypeInfo_var;
extern RuntimeClass* RemoteSettings_t1718627291_il2cpp_TypeInfo_var;
extern const RuntimeMethod* Action_1_Invoke_m1933767679_RuntimeMethod_var;
extern const RuntimeMethod* Action_3_Invoke_m1011371804_RuntimeMethod_var;
extern const uint32_t AnalyticsSessionInfo_CallSessionStateChanged_m1270932408_MetadataUsageId;
extern const uint32_t RemoteConfigSettings_Destroy_m1854335118_MetadataUsageId;
extern const uint32_t RemoteConfigSettings_RemoteConfigSettingsUpdated_m2409101234_MetadataUsageId;
extern const uint32_t RemoteConfigSettings_t1247263429_com_FromNativeMethodDefinition_MetadataUsageId;
extern const uint32_t RemoteConfigSettings_t1247263429_pinvoke_FromNativeMethodDefinition_MetadataUsageId;
extern const uint32_t RemoteSettings_RemoteSettingsBeforeFetchFromServer_m4228537265_MetadataUsageId;
extern const uint32_t RemoteSettings_RemoteSettingsUpdateCompleted_m2956290507_MetadataUsageId;
extern const uint32_t RemoteSettings_RemoteSettingsUpdated_m1182006011_MetadataUsageId;
extern const uint32_t SessionStateChanged_BeginInvoke_m1132835327_MetadataUsageId;



#ifndef U3CMODULEU3E_T692745541_H
#define U3CMODULEU3E_T692745541_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// <Module>
struct  U3CModuleU3E_t692745541 
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CMODULEU3E_T692745541_H
#ifndef RUNTIMEOBJECT_H
#define RUNTIMEOBJECT_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Object

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEOBJECT_H
struct Il2CppArrayBounds;
#ifndef RUNTIMEARRAY_H
#define RUNTIMEARRAY_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Array

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEARRAY_H
#ifndef VALUETYPE_T3640485471_H
#define VALUETYPE_T3640485471_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.ValueType
struct  ValueType_t3640485471  : public RuntimeObject
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_com
{
};
#endif // VALUETYPE_T3640485471_H
#ifndef ANALYTICSSESSIONINFO_T2322308579_H
#define ANALYTICSSESSIONINFO_T2322308579_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// UnityEngine.Analytics.AnalyticsSessionInfo
struct  AnalyticsSessionInfo_t2322308579  : public RuntimeObject
{
public:

public:
};

struct AnalyticsSessionInfo_t2322308579_StaticFields
{
public:
	// UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged UnityEngine.Analytics.AnalyticsSessionInfo::sessionStateChanged
	SessionStateChanged_t3163629820 * ___sessionStateChanged_0;

public:
	inline static int32_t get_offset_of_sessionStateChanged_0() { return static_cast<int32_t>(offsetof(AnalyticsSessionInfo_t2322308579_StaticFields, ___sessionStateChanged_0)); }
	inline SessionStateChanged_t3163629820 * get_sessionStateChanged_0() const { return ___sessionStateChanged_0; }
	inline SessionStateChanged_t3163629820 ** get_address_of_sessionStateChanged_0() { return &___sessionStateChanged_0; }
	inline void set_sessionStateChanged_0(SessionStateChanged_t3163629820 * value)
	{
		___sessionStateChanged_0 = value;
		Il2CppCodeGenWriteBarrier((&___sessionStateChanged_0), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ANALYTICSSESSIONINFO_T2322308579_H
#ifndef REMOTESETTINGS_T1718627291_H
#define REMOTESETTINGS_T1718627291_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// UnityEngine.RemoteSettings
struct  RemoteSettings_t1718627291  : public RuntimeObject
{
public:

public:
};

struct RemoteSettings_t1718627291_StaticFields
{
public:
	// UnityEngine.RemoteSettings/UpdatedEventHandler UnityEngine.RemoteSettings::Updated
	UpdatedEventHandler_t1027848393 * ___Updated_0;
	// System.Action UnityEngine.RemoteSettings::BeforeFetchFromServer
	Action_t1264377477 * ___BeforeFetchFromServer_1;
	// System.Action`3<System.Boolean,System.Boolean,System.Int32> UnityEngine.RemoteSettings::Completed
	Action_3_t3050575418 * ___Completed_2;

public:
	inline static int32_t get_offset_of_Updated_0() { return static_cast<int32_t>(offsetof(RemoteSettings_t1718627291_StaticFields, ___Updated_0)); }
	inline UpdatedEventHandler_t1027848393 * get_Updated_0() const { return ___Updated_0; }
	inline UpdatedEventHandler_t1027848393 ** get_address_of_Updated_0() { return &___Updated_0; }
	inline void set_Updated_0(UpdatedEventHandler_t1027848393 * value)
	{
		___Updated_0 = value;
		Il2CppCodeGenWriteBarrier((&___Updated_0), value);
	}

	inline static int32_t get_offset_of_BeforeFetchFromServer_1() { return static_cast<int32_t>(offsetof(RemoteSettings_t1718627291_StaticFields, ___BeforeFetchFromServer_1)); }
	inline Action_t1264377477 * get_BeforeFetchFromServer_1() const { return ___BeforeFetchFromServer_1; }
	inline Action_t1264377477 ** get_address_of_BeforeFetchFromServer_1() { return &___BeforeFetchFromServer_1; }
	inline void set_BeforeFetchFromServer_1(Action_t1264377477 * value)
	{
		___BeforeFetchFromServer_1 = value;
		Il2CppCodeGenWriteBarrier((&___BeforeFetchFromServer_1), value);
	}

	inline static int32_t get_offset_of_Completed_2() { return static_cast<int32_t>(offsetof(RemoteSettings_t1718627291_StaticFields, ___Completed_2)); }
	inline Action_3_t3050575418 * get_Completed_2() const { return ___Completed_2; }
	inline Action_3_t3050575418 ** get_address_of_Completed_2() { return &___Completed_2; }
	inline void set_Completed_2(Action_3_t3050575418 * value)
	{
		___Completed_2 = value;
		Il2CppCodeGenWriteBarrier((&___Completed_2), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REMOTESETTINGS_T1718627291_H
#ifndef BOOLEAN_T97287965_H
#define BOOLEAN_T97287965_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Boolean
struct  Boolean_t97287965 
{
public:
	// System.Boolean System.Boolean::m_value
	bool ___m_value_2;

public:
	inline static int32_t get_offset_of_m_value_2() { return static_cast<int32_t>(offsetof(Boolean_t97287965, ___m_value_2)); }
	inline bool get_m_value_2() const { return ___m_value_2; }
	inline bool* get_address_of_m_value_2() { return &___m_value_2; }
	inline void set_m_value_2(bool value)
	{
		___m_value_2 = value;
	}
};

struct Boolean_t97287965_StaticFields
{
public:
	// System.String System.Boolean::FalseString
	String_t* ___FalseString_0;
	// System.String System.Boolean::TrueString
	String_t* ___TrueString_1;

public:
	inline static int32_t get_offset_of_FalseString_0() { return static_cast<int32_t>(offsetof(Boolean_t97287965_StaticFields, ___FalseString_0)); }
	inline String_t* get_FalseString_0() const { return ___FalseString_0; }
	inline String_t** get_address_of_FalseString_0() { return &___FalseString_0; }
	inline void set_FalseString_0(String_t* value)
	{
		___FalseString_0 = value;
		Il2CppCodeGenWriteBarrier((&___FalseString_0), value);
	}

	inline static int32_t get_offset_of_TrueString_1() { return static_cast<int32_t>(offsetof(Boolean_t97287965_StaticFields, ___TrueString_1)); }
	inline String_t* get_TrueString_1() const { return ___TrueString_1; }
	inline String_t** get_address_of_TrueString_1() { return &___TrueString_1; }
	inline void set_TrueString_1(String_t* value)
	{
		___TrueString_1 = value;
		Il2CppCodeGenWriteBarrier((&___TrueString_1), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOOLEAN_T97287965_H
#ifndef ENUM_T4135868527_H
#define ENUM_T4135868527_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Enum
struct  Enum_t4135868527  : public ValueType_t3640485471
{
public:

public:
};

struct Enum_t4135868527_StaticFields
{
public:
	// System.Char[] System.Enum::split_char
	CharU5BU5D_t3528271667* ___split_char_0;

public:
	inline static int32_t get_offset_of_split_char_0() { return static_cast<int32_t>(offsetof(Enum_t4135868527_StaticFields, ___split_char_0)); }
	inline CharU5BU5D_t3528271667* get_split_char_0() const { return ___split_char_0; }
	inline CharU5BU5D_t3528271667** get_address_of_split_char_0() { return &___split_char_0; }
	inline void set_split_char_0(CharU5BU5D_t3528271667* value)
	{
		___split_char_0 = value;
		Il2CppCodeGenWriteBarrier((&___split_char_0), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t4135868527_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t4135868527_marshaled_com
{
};
#endif // ENUM_T4135868527_H
#ifndef INT32_T2950945753_H
#define INT32_T2950945753_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Int32
struct  Int32_t2950945753 
{
public:
	// System.Int32 System.Int32::m_value
	int32_t ___m_value_2;

public:
	inline static int32_t get_offset_of_m_value_2() { return static_cast<int32_t>(offsetof(Int32_t2950945753, ___m_value_2)); }
	inline int32_t get_m_value_2() const { return ___m_value_2; }
	inline int32_t* get_address_of_m_value_2() { return &___m_value_2; }
	inline void set_m_value_2(int32_t value)
	{
		___m_value_2 = value;
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT32_T2950945753_H
#ifndef INT64_T3736567304_H
#define INT64_T3736567304_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Int64
struct  Int64_t3736567304 
{
public:
	// System.Int64 System.Int64::m_value
	int64_t ___m_value_2;

public:
	inline static int32_t get_offset_of_m_value_2() { return static_cast<int32_t>(offsetof(Int64_t3736567304, ___m_value_2)); }
	inline int64_t get_m_value_2() const { return ___m_value_2; }
	inline int64_t* get_address_of_m_value_2() { return &___m_value_2; }
	inline void set_m_value_2(int64_t value)
	{
		___m_value_2 = value;
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT64_T3736567304_H
#ifndef INTPTR_T_H
#define INTPTR_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.IntPtr
struct  IntPtr_t 
{
public:
	// System.Void* System.IntPtr::m_value
	void* ___m_value_0;

public:
	inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
	inline void* get_m_value_0() const { return ___m_value_0; }
	inline void** get_address_of_m_value_0() { return &___m_value_0; }
	inline void set_m_value_0(void* value)
	{
		___m_value_0 = value;
	}
};

struct IntPtr_t_StaticFields
{
public:
	// System.IntPtr System.IntPtr::Zero
	intptr_t ___Zero_1;

public:
	inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
	inline intptr_t get_Zero_1() const { return ___Zero_1; }
	inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
	inline void set_Zero_1(intptr_t value)
	{
		___Zero_1 = value;
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INTPTR_T_H
#ifndef VOID_T1185182177_H
#define VOID_T1185182177_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Void
struct  Void_t1185182177 
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VOID_T1185182177_H
#ifndef DELEGATE_T1188392813_H
#define DELEGATE_T1188392813_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Delegate
struct  Delegate_t1188392813  : public RuntimeObject
{
public:
	// System.IntPtr System.Delegate::method_ptr
	Il2CppMethodPointer ___method_ptr_0;
	// System.IntPtr System.Delegate::invoke_impl
	intptr_t ___invoke_impl_1;
	// System.Object System.Delegate::m_target
	RuntimeObject * ___m_target_2;
	// System.IntPtr System.Delegate::method
	intptr_t ___method_3;
	// System.IntPtr System.Delegate::delegate_trampoline
	intptr_t ___delegate_trampoline_4;
	// System.IntPtr System.Delegate::method_code
	intptr_t ___method_code_5;
	// System.Reflection.MethodInfo System.Delegate::method_info
	MethodInfo_t * ___method_info_6;
	// System.Reflection.MethodInfo System.Delegate::original_method_info
	MethodInfo_t * ___original_method_info_7;
	// System.DelegateData System.Delegate::data
	DelegateData_t1677132599 * ___data_8;

public:
	inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_ptr_0)); }
	inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
	inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
	inline void set_method_ptr_0(Il2CppMethodPointer value)
	{
		___method_ptr_0 = value;
	}

	inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___invoke_impl_1)); }
	inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
	inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
	inline void set_invoke_impl_1(intptr_t value)
	{
		___invoke_impl_1 = value;
	}

	inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___m_target_2)); }
	inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
	inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
	inline void set_m_target_2(RuntimeObject * value)
	{
		___m_target_2 = value;
		Il2CppCodeGenWriteBarrier((&___m_target_2), value);
	}

	inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_3)); }
	inline intptr_t get_method_3() const { return ___method_3; }
	inline intptr_t* get_address_of_method_3() { return &___method_3; }
	inline void set_method_3(intptr_t value)
	{
		___method_3 = value;
	}

	inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___delegate_trampoline_4)); }
	inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
	inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
	inline void set_delegate_trampoline_4(intptr_t value)
	{
		___delegate_trampoline_4 = value;
	}

	inline static int32_t get_offset_of_method_code_5() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_code_5)); }
	inline intptr_t get_method_code_5() const { return ___method_code_5; }
	inline intptr_t* get_address_of_method_code_5() { return &___method_code_5; }
	inline void set_method_code_5(intptr_t value)
	{
		___method_code_5 = value;
	}

	inline static int32_t get_offset_of_method_info_6() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_info_6)); }
	inline MethodInfo_t * get_method_info_6() const { return ___method_info_6; }
	inline MethodInfo_t ** get_address_of_method_info_6() { return &___method_info_6; }
	inline void set_method_info_6(MethodInfo_t * value)
	{
		___method_info_6 = value;
		Il2CppCodeGenWriteBarrier((&___method_info_6), value);
	}

	inline static int32_t get_offset_of_original_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___original_method_info_7)); }
	inline MethodInfo_t * get_original_method_info_7() const { return ___original_method_info_7; }
	inline MethodInfo_t ** get_address_of_original_method_info_7() { return &___original_method_info_7; }
	inline void set_original_method_info_7(MethodInfo_t * value)
	{
		___original_method_info_7 = value;
		Il2CppCodeGenWriteBarrier((&___original_method_info_7), value);
	}

	inline static int32_t get_offset_of_data_8() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___data_8)); }
	inline DelegateData_t1677132599 * get_data_8() const { return ___data_8; }
	inline DelegateData_t1677132599 ** get_address_of_data_8() { return &___data_8; }
	inline void set_data_8(DelegateData_t1677132599 * value)
	{
		___data_8 = value;
		Il2CppCodeGenWriteBarrier((&___data_8), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DELEGATE_T1188392813_H
#ifndef ANALYTICSSESSIONSTATE_T681173134_H
#define ANALYTICSSESSIONSTATE_T681173134_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// UnityEngine.Analytics.AnalyticsSessionState
struct  AnalyticsSessionState_t681173134 
{
public:
	// System.Int32 UnityEngine.Analytics.AnalyticsSessionState::value__
	int32_t ___value___1;

public:
	inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(AnalyticsSessionState_t681173134, ___value___1)); }
	inline int32_t get_value___1() const { return ___value___1; }
	inline int32_t* get_address_of_value___1() { return &___value___1; }
	inline void set_value___1(int32_t value)
	{
		___value___1 = value;
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ANALYTICSSESSIONSTATE_T681173134_H
#ifndef REMOTECONFIGSETTINGS_T1247263429_H
#define REMOTECONFIGSETTINGS_T1247263429_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// UnityEngine.RemoteConfigSettings
struct  RemoteConfigSettings_t1247263429  : public RuntimeObject
{
public:
	// System.IntPtr UnityEngine.RemoteConfigSettings::m_Ptr
	intptr_t ___m_Ptr_0;
	// System.Action`1<System.Boolean> UnityEngine.RemoteConfigSettings::Updated
	Action_1_t269755560 * ___Updated_1;

public:
	inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(RemoteConfigSettings_t1247263429, ___m_Ptr_0)); }
	inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
	inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
	inline void set_m_Ptr_0(intptr_t value)
	{
		___m_Ptr_0 = value;
	}

	inline static int32_t get_offset_of_Updated_1() { return static_cast<int32_t>(offsetof(RemoteConfigSettings_t1247263429, ___Updated_1)); }
	inline Action_1_t269755560 * get_Updated_1() const { return ___Updated_1; }
	inline Action_1_t269755560 ** get_address_of_Updated_1() { return &___Updated_1; }
	inline void set_Updated_1(Action_1_t269755560 * value)
	{
		___Updated_1 = value;
		Il2CppCodeGenWriteBarrier((&___Updated_1), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of UnityEngine.RemoteConfigSettings
struct RemoteConfigSettings_t1247263429_marshaled_pinvoke
{
	intptr_t ___m_Ptr_0;
	Il2CppMethodPointer ___Updated_1;
};
// Native definition for COM marshalling of UnityEngine.RemoteConfigSettings
struct RemoteConfigSettings_t1247263429_marshaled_com
{
	intptr_t ___m_Ptr_0;
	Il2CppMethodPointer ___Updated_1;
};
#endif // REMOTECONFIGSETTINGS_T1247263429_H
#ifndef MULTICASTDELEGATE_T_H
#define MULTICASTDELEGATE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.MulticastDelegate
struct  MulticastDelegate_t  : public Delegate_t1188392813
{
public:
	// System.MulticastDelegate System.MulticastDelegate::prev
	MulticastDelegate_t * ___prev_9;
	// System.MulticastDelegate System.MulticastDelegate::kpm_next
	MulticastDelegate_t * ___kpm_next_10;

public:
	inline static int32_t get_offset_of_prev_9() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___prev_9)); }
	inline MulticastDelegate_t * get_prev_9() const { return ___prev_9; }
	inline MulticastDelegate_t ** get_address_of_prev_9() { return &___prev_9; }
	inline void set_prev_9(MulticastDelegate_t * value)
	{
		___prev_9 = value;
		Il2CppCodeGenWriteBarrier((&___prev_9), value);
	}

	inline static int32_t get_offset_of_kpm_next_10() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___kpm_next_10)); }
	inline MulticastDelegate_t * get_kpm_next_10() const { return ___kpm_next_10; }
	inline MulticastDelegate_t ** get_address_of_kpm_next_10() { return &___kpm_next_10; }
	inline void set_kpm_next_10(MulticastDelegate_t * value)
	{
		___kpm_next_10 = value;
		Il2CppCodeGenWriteBarrier((&___kpm_next_10), value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MULTICASTDELEGATE_T_H
#ifndef ACTION_T1264377477_H
#define ACTION_T1264377477_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Action
struct  Action_t1264377477  : public MulticastDelegate_t
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ACTION_T1264377477_H
#ifndef ACTION_1_T269755560_H
#define ACTION_1_T269755560_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Action`1<System.Boolean>
struct  Action_1_t269755560  : public MulticastDelegate_t
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ACTION_1_T269755560_H
#ifndef ACTION_3_T3050575418_H
#define ACTION_3_T3050575418_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.Action`3<System.Boolean,System.Boolean,System.Int32>
struct  Action_3_t3050575418  : public MulticastDelegate_t
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ACTION_3_T3050575418_H
#ifndef ASYNCCALLBACK_T3962456242_H
#define ASYNCCALLBACK_T3962456242_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// System.AsyncCallback
struct  AsyncCallback_t3962456242  : public MulticastDelegate_t
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYNCCALLBACK_T3962456242_H
#ifndef SESSIONSTATECHANGED_T3163629820_H
#define SESSIONSTATECHANGED_T3163629820_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged
struct  SessionStateChanged_t3163629820  : public MulticastDelegate_t
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SESSIONSTATECHANGED_T3163629820_H
#ifndef UPDATEDEVENTHANDLER_T1027848393_H
#define UPDATEDEVENTHANDLER_T1027848393_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif

// UnityEngine.RemoteSettings/UpdatedEventHandler
struct  UpdatedEventHandler_t1027848393  : public MulticastDelegate_t
{
public:

public:
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UPDATEDEVENTHANDLER_T1027848393_H


// System.Void System.Action`1<System.Boolean>::Invoke(!0)
extern ""C"" IL2CPP_METHOD_ATTR void Action_1_Invoke_m1933767679_gshared (Action_1_t269755560 * __this, bool p0, const RuntimeMethod* method);
// System.Void System.Action`3<System.Boolean,System.Boolean,System.Int32>::Invoke(!0,!1,!2)
extern ""C"" IL2CPP_METHOD_ATTR void Action_3_Invoke_m1011371804_gshared (Action_3_t3050575418 * __this, bool p0, bool p1, int32_t p2, const RuntimeMethod* method);

// System.Void UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged::Invoke(UnityEngine.Analytics.AnalyticsSessionState,System.Int64,System.Int64,System.Boolean)
extern ""C"" IL2CPP_METHOD_ATTR void SessionStateChanged_Invoke_m4203746932 (SessionStateChanged_t3163629820 * __this, int32_t ___sessionState0, int64_t ___sessionId1, int64_t ___sessionElapsedTime2, bool ___sessionChanged3, const RuntimeMethod* method);
// System.Void UnityEngine.RemoteConfigSettings::Destroy()
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_Destroy_m1854335118 (RemoteConfigSettings_t1247263429 * __this, const RuntimeMethod* method);
// System.Void System.Object::Finalize()
extern ""C"" IL2CPP_METHOD_ATTR void Object_Finalize_m3076187857 (RuntimeObject * __this, const RuntimeMethod* method);
// System.Boolean System.IntPtr::op_Inequality(System.IntPtr,System.IntPtr)
extern ""C"" IL2CPP_METHOD_ATTR bool IntPtr_op_Inequality_m3063970704 (RuntimeObject * __this /* static, unused */, intptr_t p0, intptr_t p1, const RuntimeMethod* method);
// System.Void UnityEngine.RemoteConfigSettings::Internal_Destroy(System.IntPtr)
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_Internal_Destroy_m1072151938 (RuntimeObject * __this /* static, unused */, intptr_t ___ptr0, const RuntimeMethod* method);
// System.Void System.GC::SuppressFinalize(System.Object)
extern ""C"" IL2CPP_METHOD_ATTR void GC_SuppressFinalize_m1177400158 (RuntimeObject * __this /* static, unused */, RuntimeObject * p0, const RuntimeMethod* method);
// System.Void System.Action`1<System.Boolean>::Invoke(!0)
inline void Action_1_Invoke_m1933767679 (Action_1_t269755560 * __this, bool p0, const RuntimeMethod* method)
{
	((  void (*) (Action_1_t269755560 *, bool, const RuntimeMethod*))Action_1_Invoke_m1933767679_gshared)(__this, p0, method);
}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::Invoke()
extern ""C"" IL2CPP_METHOD_ATTR void UpdatedEventHandler_Invoke_m3026613363 (UpdatedEventHandler_t1027848393 * __this, const RuntimeMethod* method);
// System.Void System.Action::Invoke()
extern ""C"" IL2CPP_METHOD_ATTR void Action_Invoke_m937035532 (Action_t1264377477 * __this, const RuntimeMethod* method);
// System.Void System.Action`3<System.Boolean,System.Boolean,System.Int32>::Invoke(!0,!1,!2)
inline void Action_3_Invoke_m1011371804 (Action_3_t3050575418 * __this, bool p0, bool p1, int32_t p2, const RuntimeMethod* method)
{
	((  void (*) (Action_3_t3050575418 *, bool, bool, int32_t, const RuntimeMethod*))Action_3_Invoke_m1011371804_gshared)(__this, p0, p1, p2, method);
}
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
// System.Void UnityEngine.Analytics.AnalyticsSessionInfo::CallSessionStateChanged(UnityEngine.Analytics.AnalyticsSessionState,System.Int64,System.Int64,System.Boolean)
extern ""C"" IL2CPP_METHOD_ATTR void AnalyticsSessionInfo_CallSessionStateChanged_m1270932408 (RuntimeObject * __this /* static, unused */, int32_t ___sessionState0, int64_t ___sessionId1, int64_t ___sessionElapsedTime2, bool ___sessionChanged3, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (AnalyticsSessionInfo_CallSessionStateChanged_m1270932408_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	SessionStateChanged_t3163629820 * V_0 = NULL;
	{
		SessionStateChanged_t3163629820 * L_0 = ((AnalyticsSessionInfo_t2322308579_StaticFields*)il2cpp_codegen_static_fields_for(AnalyticsSessionInfo_t2322308579_il2cpp_TypeInfo_var))->get_sessionStateChanged_0();
		V_0 = L_0;
		SessionStateChanged_t3163629820 * L_1 = V_0;
		if (!L_1)
		{
			goto IL_0017;
		}
	}
	{
		SessionStateChanged_t3163629820 * L_2 = V_0;
		int32_t L_3 = ___sessionState0;
		int64_t L_4 = ___sessionId1;
		int64_t L_5 = ___sessionElapsedTime2;
		bool L_6 = ___sessionChanged3;
		NullCheck(L_2);
		SessionStateChanged_Invoke_m4203746932(L_2, L_3, L_4, L_5, L_6, /*hidden argument*/NULL);
	}

IL_0017:
	{
		return;
	}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
extern ""C""  void DelegatePInvokeWrapper_SessionStateChanged_t3163629820 (SessionStateChanged_t3163629820 * __this, int32_t ___sessionState0, int64_t ___sessionId1, int64_t ___sessionElapsedTime2, bool ___sessionChanged3, const RuntimeMethod* method)
{
	typedef void (DEFAULT_CALL *PInvokeFunc)(int32_t, int64_t, int64_t, int32_t);
	PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));

	// Native function invocation
	il2cppPInvokeFunc(___sessionState0, ___sessionId1, ___sessionElapsedTime2, static_cast<int32_t>(___sessionChanged3));

}
// System.Void UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged::.ctor(System.Object,System.IntPtr)
extern ""C"" IL2CPP_METHOD_ATTR void SessionStateChanged__ctor_m2637910444 (SessionStateChanged_t3163629820 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
	__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
	__this->set_method_3(___method1);
	__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged::Invoke(UnityEngine.Analytics.AnalyticsSessionState,System.Int64,System.Int64,System.Boolean)
extern ""C"" IL2CPP_METHOD_ATTR void SessionStateChanged_Invoke_m4203746932 (SessionStateChanged_t3163629820 * __this, int32_t ___sessionState0, int64_t ___sessionId1, int64_t ___sessionElapsedTime2, bool ___sessionChanged3, const RuntimeMethod* method)
{
	if(__this->get_prev_9() != NULL)
	{
		SessionStateChanged_Invoke_m4203746932((SessionStateChanged_t3163629820 *)__this->get_prev_9(), ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3, method);
	}
	Il2CppMethodPointer targetMethodPointer = __this->get_method_ptr_0();
	RuntimeMethod* targetMethod = (RuntimeMethod*)(__this->get_method_3());
	RuntimeObject* targetThis = __this->get_m_target_2();
	il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
	bool ___methodIsStatic = MethodIsStatic(targetMethod);
	if (___methodIsStatic)
	{
		if (il2cpp_codegen_method_parameter_count(targetMethod) == 4)
		{
			// open
			{
				typedef void (*FunctionPointerType) (RuntimeObject *, int32_t, int64_t, int64_t, bool, const RuntimeMethod*);
				((FunctionPointerType)targetMethodPointer)(NULL, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3, targetMethod);
			}
		}
		else
		{
			// closed
			{
				typedef void (*FunctionPointerType) (RuntimeObject *, void*, int32_t, int64_t, int64_t, bool, const RuntimeMethod*);
				((FunctionPointerType)targetMethodPointer)(NULL, targetThis, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3, targetMethod);
			}
		}
	}
	else
	{
		{
			// closed
			if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
			{
				if (il2cpp_codegen_method_is_generic_instance(targetMethod))
				{
					if (il2cpp_codegen_method_is_interface_method(targetMethod))
						GenericInterfaceActionInvoker4< int32_t, int64_t, int64_t, bool >::Invoke(targetMethod, targetThis, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3);
					else
						GenericVirtActionInvoker4< int32_t, int64_t, int64_t, bool >::Invoke(targetMethod, targetThis, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3);
				}
				else
				{
					if (il2cpp_codegen_method_is_interface_method(targetMethod))
						InterfaceActionInvoker4< int32_t, int64_t, int64_t, bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3);
					else
						VirtActionInvoker4< int32_t, int64_t, int64_t, bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3);
				}
			}
			else
			{
				typedef void (*FunctionPointerType) (void*, int32_t, int64_t, int64_t, bool, const RuntimeMethod*);
				((FunctionPointerType)targetMethodPointer)(targetThis, ___sessionState0, ___sessionId1, ___sessionElapsedTime2, ___sessionChanged3, targetMethod);
			}
		}
	}
}
// System.IAsyncResult UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged::BeginInvoke(UnityEngine.Analytics.AnalyticsSessionState,System.Int64,System.Int64,System.Boolean,System.AsyncCallback,System.Object)
extern ""C"" IL2CPP_METHOD_ATTR RuntimeObject* SessionStateChanged_BeginInvoke_m1132835327 (SessionStateChanged_t3163629820 * __this, int32_t ___sessionState0, int64_t ___sessionId1, int64_t ___sessionElapsedTime2, bool ___sessionChanged3, AsyncCallback_t3962456242 * ___callback4, RuntimeObject * ___object5, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (SessionStateChanged_BeginInvoke_m1132835327_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	void *__d_args[5] = {0};
	__d_args[0] = Box(AnalyticsSessionState_t681173134_il2cpp_TypeInfo_var, &___sessionState0);
	__d_args[1] = Box(Int64_t3736567304_il2cpp_TypeInfo_var, &___sessionId1);
	__d_args[2] = Box(Int64_t3736567304_il2cpp_TypeInfo_var, &___sessionElapsedTime2);
	__d_args[3] = Box(Boolean_t97287965_il2cpp_TypeInfo_var, &___sessionChanged3);
	return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback4, (RuntimeObject*)___object5);
}
// System.Void UnityEngine.Analytics.AnalyticsSessionInfo/SessionStateChanged::EndInvoke(System.IAsyncResult)
extern ""C"" IL2CPP_METHOD_ATTR void SessionStateChanged_EndInvoke_m3581055289 (SessionStateChanged_t3163629820 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
	il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
// Conversion methods for marshalling of: UnityEngine.RemoteConfigSettings
extern ""C"" void RemoteConfigSettings_t1247263429_marshal_pinvoke(const RemoteConfigSettings_t1247263429& unmarshaled, RemoteConfigSettings_t1247263429_marshaled_pinvoke& marshaled)
{
	marshaled.___m_Ptr_0 = unmarshaled.get_m_Ptr_0();
	marshaled.___Updated_1 = il2cpp_codegen_marshal_delegate(reinterpret_cast<MulticastDelegate_t*>(unmarshaled.get_Updated_1()));
}
extern ""C"" void RemoteConfigSettings_t1247263429_marshal_pinvoke_back(const RemoteConfigSettings_t1247263429_marshaled_pinvoke& marshaled, RemoteConfigSettings_t1247263429& unmarshaled)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteConfigSettings_t1247263429_pinvoke_FromNativeMethodDefinition_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	intptr_t unmarshaled_m_Ptr_temp_0;
	memset(&unmarshaled_m_Ptr_temp_0, 0, sizeof(unmarshaled_m_Ptr_temp_0));
	unmarshaled_m_Ptr_temp_0 = marshaled.___m_Ptr_0;
	unmarshaled.set_m_Ptr_0(unmarshaled_m_Ptr_temp_0);
	unmarshaled.set_Updated_1(il2cpp_codegen_marshal_function_ptr_to_delegate<Action_1_t269755560>(marshaled.___Updated_1, Action_1_t269755560_il2cpp_TypeInfo_var));
}
// Conversion method for clean up from marshalling of: UnityEngine.RemoteConfigSettings
extern ""C"" void RemoteConfigSettings_t1247263429_marshal_pinvoke_cleanup(RemoteConfigSettings_t1247263429_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.RemoteConfigSettings
extern ""C"" void RemoteConfigSettings_t1247263429_marshal_com(const RemoteConfigSettings_t1247263429& unmarshaled, RemoteConfigSettings_t1247263429_marshaled_com& marshaled)
{
	marshaled.___m_Ptr_0 = unmarshaled.get_m_Ptr_0();
	marshaled.___Updated_1 = il2cpp_codegen_marshal_delegate(reinterpret_cast<MulticastDelegate_t*>(unmarshaled.get_Updated_1()));
}
extern ""C"" void RemoteConfigSettings_t1247263429_marshal_com_back(const RemoteConfigSettings_t1247263429_marshaled_com& marshaled, RemoteConfigSettings_t1247263429& unmarshaled)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteConfigSettings_t1247263429_com_FromNativeMethodDefinition_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	intptr_t unmarshaled_m_Ptr_temp_0;
	memset(&unmarshaled_m_Ptr_temp_0, 0, sizeof(unmarshaled_m_Ptr_temp_0));
	unmarshaled_m_Ptr_temp_0 = marshaled.___m_Ptr_0;
	unmarshaled.set_m_Ptr_0(unmarshaled_m_Ptr_temp_0);
	unmarshaled.set_Updated_1(il2cpp_codegen_marshal_function_ptr_to_delegate<Action_1_t269755560>(marshaled.___Updated_1, Action_1_t269755560_il2cpp_TypeInfo_var));
}
// Conversion method for clean up from marshalling of: UnityEngine.RemoteConfigSettings
extern ""C"" void RemoteConfigSettings_t1247263429_marshal_com_cleanup(RemoteConfigSettings_t1247263429_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.RemoteConfigSettings::Finalize()
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_Finalize_m2805990196 (RemoteConfigSettings_t1247263429 * __this, const RuntimeMethod* method)
{
	Exception_t * __last_unhandled_exception = 0;
	NO_UNUSED_WARNING (__last_unhandled_exception);
	Exception_t * __exception_local = 0;
	NO_UNUSED_WARNING (__exception_local);
	int32_t __leave_target = -1;
	NO_UNUSED_WARNING (__leave_target);
	{
	}

IL_0001:
	try
	{ // begin try (depth: 1)
		RemoteConfigSettings_Destroy_m1854335118(__this, /*hidden argument*/NULL);
		IL2CPP_LEAVE(0x13, FINALLY_000c);
	} // end try (depth: 1)
	catch(Il2CppExceptionWrapper& e)
	{
		__last_unhandled_exception = (Exception_t *)e.ex;
		goto FINALLY_000c;
	}

FINALLY_000c:
	{ // begin finally (depth: 1)
		Object_Finalize_m3076187857(__this, /*hidden argument*/NULL);
		IL2CPP_END_FINALLY(12)
	} // end finally (depth: 1)
	IL2CPP_CLEANUP(12)
	{
		IL2CPP_JUMP_TBL(0x13, IL_0013)
		IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
	}

IL_0013:
	{
		return;
	}
}
// System.Void UnityEngine.RemoteConfigSettings::Destroy()
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_Destroy_m1854335118 (RemoteConfigSettings_t1247263429 * __this, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteConfigSettings_Destroy_m1854335118_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	{
		intptr_t L_0 = __this->get_m_Ptr_0();
		bool L_1 = IntPtr_op_Inequality_m3063970704(NULL /*static, unused*/, L_0, (intptr_t)(0), /*hidden argument*/NULL);
		if (!L_1)
		{
			goto IL_002e;
		}
	}
	{
		intptr_t L_2 = __this->get_m_Ptr_0();
		RemoteConfigSettings_Internal_Destroy_m1072151938(NULL /*static, unused*/, L_2, /*hidden argument*/NULL);
		__this->set_m_Ptr_0((intptr_t)(0));
	}

IL_002e:
	{
		return;
	}
}
// System.Void UnityEngine.RemoteConfigSettings::Dispose()
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_Dispose_m2083915538 (RemoteConfigSettings_t1247263429 * __this, const RuntimeMethod* method)
{
	{
		RemoteConfigSettings_Destroy_m1854335118(__this, /*hidden argument*/NULL);
		GC_SuppressFinalize_m1177400158(NULL /*static, unused*/, __this, /*hidden argument*/NULL);
		return;
	}
}
// System.Void UnityEngine.RemoteConfigSettings::Internal_Destroy(System.IntPtr)
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_Internal_Destroy_m1072151938 (RuntimeObject * __this /* static, unused */, intptr_t ___ptr0, const RuntimeMethod* method)
{
	typedef void (*RemoteConfigSettings_Internal_Destroy_m1072151938_ftn) (intptr_t);
	static RemoteConfigSettings_Internal_Destroy_m1072151938_ftn _il2cpp_icall_func;
	if (!_il2cpp_icall_func)
	_il2cpp_icall_func = (RemoteConfigSettings_Internal_Destroy_m1072151938_ftn)il2cpp_codegen_resolve_icall (""UnityEngine.RemoteConfigSettings::Internal_Destroy(System.IntPtr)"");
	_il2cpp_icall_func(___ptr0);
}
// System.Void UnityEngine.RemoteConfigSettings::RemoteConfigSettingsUpdated(UnityEngine.RemoteConfigSettings,System.Boolean)
extern ""C"" IL2CPP_METHOD_ATTR void RemoteConfigSettings_RemoteConfigSettingsUpdated_m2409101234 (RuntimeObject * __this /* static, unused */, RemoteConfigSettings_t1247263429 * ___rcs0, bool ___wasLastUpdatedFromServer1, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteConfigSettings_RemoteConfigSettingsUpdated_m2409101234_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	Action_1_t269755560 * V_0 = NULL;
	{
		RemoteConfigSettings_t1247263429 * L_0 = ___rcs0;
		NullCheck(L_0);
		Action_1_t269755560 * L_1 = L_0->get_Updated_1();
		V_0 = L_1;
		Action_1_t269755560 * L_2 = V_0;
		if (!L_2)
		{
			goto IL_0015;
		}
	}
	{
		Action_1_t269755560 * L_3 = V_0;
		bool L_4 = ___wasLastUpdatedFromServer1;
		NullCheck(L_3);
		Action_1_Invoke_m1933767679(L_3, L_4, /*hidden argument*/Action_1_Invoke_m1933767679_RuntimeMethod_var);
	}

IL_0015:
	{
		return;
	}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
// System.Void UnityEngine.RemoteSettings::RemoteSettingsUpdated(System.Boolean)
extern ""C"" IL2CPP_METHOD_ATTR void RemoteSettings_RemoteSettingsUpdated_m1182006011 (RuntimeObject * __this /* static, unused */, bool ___wasLastUpdatedFromServer0, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteSettings_RemoteSettingsUpdated_m1182006011_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	UpdatedEventHandler_t1027848393 * V_0 = NULL;
	{
		UpdatedEventHandler_t1027848393 * L_0 = ((RemoteSettings_t1718627291_StaticFields*)il2cpp_codegen_static_fields_for(RemoteSettings_t1718627291_il2cpp_TypeInfo_var))->get_Updated_0();
		V_0 = L_0;
		UpdatedEventHandler_t1027848393 * L_1 = V_0;
		if (!L_1)
		{
			goto IL_0013;
		}
	}
	{
		UpdatedEventHandler_t1027848393 * L_2 = V_0;
		NullCheck(L_2);
		UpdatedEventHandler_Invoke_m3026613363(L_2, /*hidden argument*/NULL);
	}

IL_0013:
	{
		return;
	}
}
// System.Void UnityEngine.RemoteSettings::RemoteSettingsBeforeFetchFromServer()
extern ""C"" IL2CPP_METHOD_ATTR void RemoteSettings_RemoteSettingsBeforeFetchFromServer_m4228537265 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteSettings_RemoteSettingsBeforeFetchFromServer_m4228537265_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	Action_t1264377477 * V_0 = NULL;
	{
		Action_t1264377477 * L_0 = ((RemoteSettings_t1718627291_StaticFields*)il2cpp_codegen_static_fields_for(RemoteSettings_t1718627291_il2cpp_TypeInfo_var))->get_BeforeFetchFromServer_1();
		V_0 = L_0;
		Action_t1264377477 * L_1 = V_0;
		if (!L_1)
		{
			goto IL_0013;
		}
	}
	{
		Action_t1264377477 * L_2 = V_0;
		NullCheck(L_2);
		Action_Invoke_m937035532(L_2, /*hidden argument*/NULL);
	}

IL_0013:
	{
		return;
	}
}
// System.Void UnityEngine.RemoteSettings::RemoteSettingsUpdateCompleted(System.Boolean,System.Boolean,System.Int32)
extern ""C"" IL2CPP_METHOD_ATTR void RemoteSettings_RemoteSettingsUpdateCompleted_m2956290507 (RuntimeObject * __this /* static, unused */, bool ___wasLastUpdatedFromServer0, bool ___settingsChanged1, int32_t ___response2, const RuntimeMethod* method)
{
	static bool s_Il2CppMethodInitialized;
	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (RemoteSettings_RemoteSettingsUpdateCompleted_m2956290507_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	Action_3_t3050575418 * V_0 = NULL;
	{
		Action_3_t3050575418 * L_0 = ((RemoteSettings_t1718627291_StaticFields*)il2cpp_codegen_static_fields_for(RemoteSettings_t1718627291_il2cpp_TypeInfo_var))->get_Completed_2();
		V_0 = L_0;
		Action_3_t3050575418 * L_1 = V_0;
		if (!L_1)
		{
			goto IL_0016;
		}
	}
	{
		Action_3_t3050575418 * L_2 = V_0;
		bool L_3 = ___wasLastUpdatedFromServer0;
		bool L_4 = ___settingsChanged1;
		int32_t L_5 = ___response2;
		NullCheck(L_2);
		Action_3_Invoke_m1011371804(L_2, L_3, L_4, L_5, /*hidden argument*/Action_3_Invoke_m1011371804_RuntimeMethod_var);
	}

IL_0016:
	{
		return;
	}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored ""-Winvalid-offsetof""
#pragma clang diagnostic ignored ""-Wunused-variable""
#endif
extern ""C""  void DelegatePInvokeWrapper_UpdatedEventHandler_t1027848393 (UpdatedEventHandler_t1027848393 * __this, const RuntimeMethod* method)
{
	typedef void (DEFAULT_CALL *PInvokeFunc)();
	PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));

	// Native function invocation
	il2cppPInvokeFunc();

}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::.ctor(System.Object,System.IntPtr)
extern ""C"" IL2CPP_METHOD_ATTR void UpdatedEventHandler__ctor_m3406570235 (UpdatedEventHandler_t1027848393 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
	__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
	__this->set_method_3(___method1);
	__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::Invoke()
extern ""C"" IL2CPP_METHOD_ATTR void UpdatedEventHandler_Invoke_m3026613363 (UpdatedEventHandler_t1027848393 * __this, const RuntimeMethod* method)
{
	if(__this->get_prev_9() != NULL)
	{
		UpdatedEventHandler_Invoke_m3026613363((UpdatedEventHandler_t1027848393 *)__this->get_prev_9(), method);
	}
	Il2CppMethodPointer targetMethodPointer = __this->get_method_ptr_0();
	RuntimeMethod* targetMethod = (RuntimeMethod*)(__this->get_method_3());
	RuntimeObject* targetThis = __this->get_m_target_2();
	il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
	bool ___methodIsStatic = MethodIsStatic(targetMethod);
	if (___methodIsStatic)
	{
		if (il2cpp_codegen_method_parameter_count(targetMethod) == 0)
		{
			// open
			{
				typedef void (*FunctionPointerType) (RuntimeObject *, const RuntimeMethod*);
				((FunctionPointerType)targetMethodPointer)(NULL, targetMethod);
			}
		}
		else
		{
			// closed
			{
				typedef void (*FunctionPointerType) (RuntimeObject *, void*, const RuntimeMethod*);
				((FunctionPointerType)targetMethodPointer)(NULL, targetThis, targetMethod);
			}
		}
	}
	else
	{
		{
			// closed
			if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
			{
				if (il2cpp_codegen_method_is_generic_instance(targetMethod))
				{
					if (il2cpp_codegen_method_is_interface_method(targetMethod))
						GenericInterfaceActionInvoker0::Invoke(targetMethod, targetThis);
					else
						GenericVirtActionInvoker0::Invoke(targetMethod, targetThis);
				}
				else
				{
					if (il2cpp_codegen_method_is_interface_method(targetMethod))
						InterfaceActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis);
					else
						VirtActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis);
				}
			}
			else
			{
				typedef void (*FunctionPointerType) (void*, const RuntimeMethod*);
				((FunctionPointerType)targetMethodPointer)(targetThis, targetMethod);
			}
		}
	}
}
// System.IAsyncResult UnityEngine.RemoteSettings/UpdatedEventHandler::BeginInvoke(System.AsyncCallback,System.Object)
extern ""C"" IL2CPP_METHOD_ATTR RuntimeObject* UpdatedEventHandler_BeginInvoke_m424999959 (UpdatedEventHandler_t1027848393 * __this, AsyncCallback_t3962456242 * ___callback0, RuntimeObject * ___object1, const RuntimeMethod* method)
{
	void *__d_args[1] = {0};
	return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback0, (RuntimeObject*)___object1);
}
// System.Void UnityEngine.RemoteSettings/UpdatedEventHandler::EndInvoke(System.IAsyncResult)
extern ""C"" IL2CPP_METHOD_ATTR void UpdatedEventHandler_EndInvoke_m3714202114 (UpdatedEventHandler_t1027848393 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
	il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
",16172,True,3324.7083324786836,median
"[[features.testing]]
== Testing
Spring Boot provides a number of utilities and annotations to help when testing your application.
Test support is provided by two modules: `spring-boot-test` contains core items, and `spring-boot-test-autoconfigure` supports auto-configuration for tests.

Most developers use the `spring-boot-starter-test` ""`Starter`"", which imports both Spring Boot test modules as well as JUnit Jupiter, AssertJ, Hamcrest, and a number of other useful libraries.

[TIP]
====
If you have tests that use JUnit 4, JUnit 5's vintage engine can be used to run them.
To use the vintage engine, add a dependency on `junit-vintage-engine`, as shown in the following example:

[source,xml,indent=0,subs=""verbatim""]
----
	<dependency>
		<groupId>org.junit.vintage</groupId>
		<artifactId>junit-vintage-engine</artifactId>
		<scope>test</scope>
		<exclusions>
			<exclusion>
				<groupId>org.hamcrest</groupId>
				<artifactId>hamcrest-core</artifactId>
			</exclusion>
		</exclusions>
	</dependency>
----
====

`hamcrest-core` is excluded in favor of `org.hamcrest:hamcrest` that is part of `spring-boot-starter-test`.



[[features.testing.test-scope-dependencies]]
=== Test Scope Dependencies
The `spring-boot-starter-test` ""`Starter`"" (in the `test` `scope`) contains the following provided libraries:

* https://junit.org/junit5/[JUnit 5]: The de-facto standard for unit testing Java applications.
* {spring-framework-docs}/testing.html#integration-testing[Spring Test] & Spring Boot Test: Utilities and integration test support for Spring Boot applications.
* https://assertj.github.io/doc/[AssertJ]: A fluent assertion library.
* https://github.com/hamcrest/JavaHamcrest[Hamcrest]: A library of matcher objects (also known as constraints or predicates).
* https://site.mockito.org/[Mockito]: A Java mocking framework.
* https://github.com/skyscreamer/JSONassert[JSONassert]: An assertion library for JSON.
* https://github.com/jayway/JsonPath[JsonPath]: XPath for JSON.

We generally find these common libraries to be useful when writing tests.
If these libraries do not suit your needs, you can add additional test dependencies of your own.



[[features.testing.spring-applications]]
=== Testing Spring Applications
One of the major advantages of dependency injection is that it should make your code easier to unit test.
You can instantiate objects by using the `new` operator without even involving Spring.
You can also use _mock objects_ instead of real dependencies.

Often, you need to move beyond unit testing and start integration testing (with a Spring `ApplicationContext`).
It is useful to be able to perform integration testing without requiring deployment of your application or needing to connect to other infrastructure.

The Spring Framework includes a dedicated test module for such integration testing.
You can declare a dependency directly to `org.springframework:spring-test` or use the `spring-boot-starter-test` ""`Starter`"" to pull it in transitively.

If you have not used the `spring-test` module before, you should start by reading the {spring-framework-docs}/testing.html#testing[relevant section] of the Spring Framework reference documentation.



[[features.testing.spring-boot-applications]]
=== Testing Spring Boot Applications
A Spring Boot application is a Spring `ApplicationContext`, so nothing very special has to be done to test it beyond what you would normally do with a vanilla Spring context.

NOTE: External properties, logging, and other features of Spring Boot are installed in the context by default only if you use `SpringApplication` to create it.

Spring Boot provides a `@SpringBootTest` annotation, which can be used as an alternative to the standard `spring-test` `@ContextConfiguration` annotation when you need Spring Boot features.
The annotation works by <<features#features.testing.spring-boot-applications.detecting-configuration,creating the `ApplicationContext` used in your tests through `SpringApplication`>>.
In addition to `@SpringBootTest` a number of other annotations are also provided for <<features#features.testing.spring-boot-applications.autoconfigured-tests,testing more specific slices>> of an application.

TIP: If you are using JUnit 4, don't forget to also add `@RunWith(SpringRunner.class)` to your test, otherwise the annotations will be ignored.
If you are using JUnit 5, there's no need to add the equivalent `@ExtendWith(SpringExtension.class)` as `@SpringBootTest` and the other `@...Test` annotations are already annotated with it.

By default, `@SpringBootTest` will not start a server.
You can use the `webEnvironment` attribute of `@SpringBootTest` to further refine how your tests run:

* `MOCK`(Default) : Loads a web `ApplicationContext` and provides a mock web environment.
  Embedded servers are not started when using this annotation.
	If a web environment is not available on your classpath, this mode transparently falls back to creating a regular non-web `ApplicationContext`.
	It can be used in conjunction with <<features#features.testing.spring-boot-applications.with-mock-environment, `@AutoConfigureMockMvc` or `@AutoConfigureWebTestClient`>> for mock-based testing of your web application.
* `RANDOM_PORT`: Loads a `WebServerApplicationContext` and provides a real web environment.
  Embedded servers are started and listen on a random port.
* `DEFINED_PORT`: Loads a `WebServerApplicationContext` and provides a real web environment.
  Embedded servers are started and listen on a defined port (from your `application.properties`) or on the default port of `8080`.
* `NONE`: Loads an `ApplicationContext` by using `SpringApplication` but does not provide _any_ web environment (mock or otherwise).

NOTE: If your test is `@Transactional`, it rolls back the transaction at the end of each test method by default.
However, as using this arrangement with either `RANDOM_PORT` or `DEFINED_PORT` implicitly provides a real servlet environment, the HTTP client and server run in separate threads and, thus, in separate transactions.
Any transaction initiated on the server does not roll back in this case.

NOTE: `@SpringBootTest` with `webEnvironment = WebEnvironment.RANDOM_PORT` will also start the management server on a separate random port if your application uses a different port for the management server.



[[features.testing.spring-boot-applications.detecting-web-app-type]]
==== Detecting Web Application Type
If Spring MVC is available, a regular MVC-based application context is configured.
If you have only Spring WebFlux, we'll detect that and configure a WebFlux-based application context instead.

If both are present, Spring MVC takes precedence.
If you want to test a reactive web application in this scenario, you must set the configprop:spring.main.web-application-type[] property:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/detectingwebapptype/MyWebFluxTests.java[]
----



[[features.testing.spring-boot-applications.detecting-configuration]]
==== Detecting Test Configuration
If you are familiar with the Spring Test Framework, you may be used to using `@ContextConfiguration(classes=...)` in order to specify which Spring `@Configuration` to load.
Alternatively, you might have often used nested `@Configuration` classes within your test.

When testing Spring Boot applications, this is often not required.
Spring Boot's `@*Test` annotations search for your primary configuration automatically whenever you do not explicitly define one.

The search algorithm works up from the package that contains the test until it finds a class annotated with `@SpringBootApplication` or `@SpringBootConfiguration`.
As long as you <<using#using.structuring-your-code, structured your code>> in a sensible way, your main configuration is usually found.

[NOTE]
====
If you use a <<features#features.testing.spring-boot-applications.autoconfigured-tests, test annotation to test a more specific slice of your application>>, you should avoid adding configuration settings that are specific to a particular area on the <<features#features.testing.spring-boot-applications.user-configuration-and-slicing, main method's application class>>.

The underlying component scan configuration of `@SpringBootApplication` defines exclude filters that are used to make sure slicing works as expected.
If you are using an explicit `@ComponentScan` directive on your `@SpringBootApplication`-annotated class, be aware that those filters will be disabled.
If you are using slicing, you should define them again.
====

If you want to customize the primary configuration, you can use a nested `@TestConfiguration` class.
Unlike a nested `@Configuration` class, which would be used instead of your application's primary configuration, a nested `@TestConfiguration` class is used in addition to your application's primary configuration.

NOTE: Spring's test framework caches application contexts between tests.
Therefore, as long as your tests share the same configuration (no matter how it is discovered), the potentially time-consuming process of loading the context happens only once.



[[features.testing.spring-boot-applications.excluding-configuration]]
==== Excluding Test Configuration
If your application uses component scanning (for example, if you use `@SpringBootApplication` or `@ComponentScan`), you may find top-level configuration classes that you created only for specific tests accidentally get picked up everywhere.

As we <<features#features.testing.spring-boot-applications.detecting-configuration,have seen earlier>>, `@TestConfiguration` can be used on an inner class of a test to customize the primary configuration.
When placed on a top-level class, `@TestConfiguration` indicates that classes in `src/test/java` should not be picked up by scanning.
You can then import that class explicitly where it is required, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/excludingconfiguration/MyTests.java[]
----

NOTE: If you directly use `@ComponentScan` (that is, not through `@SpringBootApplication`) you need to register the `TypeExcludeFilter` with it.
See {spring-boot-module-api}/context/TypeExcludeFilter.html[the Javadoc] for details.



[[features.testing.spring-boot-applications.using-application-arguments]]
==== Using Application Arguments
If your application expects <<features#features.spring-application.application-arguments,arguments>>, you can
have `@SpringBootTest` inject them using the `args` attribute.

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/usingapplicationarguments/MyApplicationArgumentTests.java[]
----



[[features.testing.spring-boot-applications.with-mock-environment]]
==== Testing with a mock environment
By default, `@SpringBootTest` does not start the server.
If you have web endpoints that you want to test against this mock environment, you can additionally configure {spring-framework-docs}/testing.html#spring-mvc-test-framework[`MockMvc`] as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withmockenvironment/MyMockMvcTests.java[]
----

TIP: If you want to focus only on the web layer and not start a complete `ApplicationContext`, consider <<features#features.testing.spring-boot-applications.spring-mvc-tests,using `@WebMvcTest` instead>>.

Alternatively, you can configure a {spring-framework-docs}/testing.html#webtestclient-tests[`WebTestClient`] as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withmockenvironment/MyMockWebTestClientTests.java[]
----

[TIP]
====
Testing within a mocked environment is usually faster than running with a full Servlet container.
However, since mocking occurs at the Spring MVC layer, code that relies on lower-level Servlet container behavior cannot be directly tested with MockMvc.

For example, Spring Boot's error handling is based on the ""`error page`"" support provided by the Servlet container.
This means that, whilst you can test your MVC layer throws and handles exceptions as expected, you cannot directly test that a specific <<features#features.developing-web-applications.spring-mvc.error-handling.error-pages, custom error page>> is rendered.
If you need to test these lower-level concerns, you can start a fully running server as described in the next section.
====



[[features.testing.spring-boot-applications.with-running-server]]
==== Testing with a running server
If you need to start a full running server, we recommend that you use random ports.
If you use `@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)`, an available port is picked at random each time your test runs.

The `@LocalServerPort` annotation can be used to <<howto#howto.webserver.discover-port,inject the actual port used>> into your test.
For convenience, tests that need to make REST calls to the started server can additionally `@Autowire` a {spring-framework-docs}/testing.html#webtestclient-tests[`WebTestClient`], which resolves relative links to the running server and comes with a dedicated API for verifying responses, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withrunningserver/MyRandomPortWebTestClientTests.java[]
----

This setup requires `spring-webflux` on the classpath.
If you can't or won't add webflux, Spring Boot also provides a `TestRestTemplate` facility:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withrunningserver/MyRandomPortTestRestTemplateTests.java[]
----



[[features.testing.spring-boot-applications.customizing-web-test-client]]
==== Customizing WebTestClient
To customize the `WebTestClient` bean, configure a `WebTestClientBuilderCustomizer` bean.
Any such beans are called with the `WebTestClient.Builder` that is used to create the `WebTestClient`.



[[features.testing.spring-boot-applications.jmx]]
==== Using JMX
As the test context framework caches context, JMX is disabled by default to prevent identical components to register on the same domain.
If such test needs access to an `MBeanServer`, consider marking it dirty as well:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/jmx/MyJmxTests.java[]
----



[[features.testing.spring-boot-applications.metrics]]
==== Using Metrics
Regardless of your classpath, meter registries, except the in-memory backed, are not auto-configured when using `@SpringBootTest`.

If you need to export metrics to a different backend as part of an integration test, annotate it with `@AutoConfigureMetrics`.



[[features.testing.spring-boot-applications.mocking-beans]]
==== Mocking and Spying Beans
When running tests, it is sometimes necessary to mock certain components within your application context.
For example, you may have a facade over some remote service that is unavailable during development.
Mocking can also be useful when you want to simulate failures that might be hard to trigger in a real environment.

Spring Boot includes a `@MockBean` annotation that can be used to define a Mockito mock for a bean inside your `ApplicationContext`.
You can use the annotation to add new beans or replace a single existing bean definition.
The annotation can be used directly on test classes, on fields within your test, or on `@Configuration` classes and fields.
When used on a field, the instance of the created mock is also injected.
Mock beans are automatically reset after each test method.

[NOTE]
====
If your test uses one of Spring Boot's test annotations (such as `@SpringBootTest`), this feature is automatically enabled.
To use this feature with a different arrangement, listeners must be explicitly added, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/mockingbeans/listener/MyTests.java[]
----

====

The following example replaces an existing `RemoteService` bean with a mock implementation:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/mockingbeans/bean/MyTests.java[]
----

NOTE: `@MockBean` cannot be used to mock the behavior of a bean that's exercised during application context refresh.
By the time the test is executed, the application context refresh has completed and it is too late to configure the mocked behavior.
We recommend using a `@Bean` method to create and configure the mock in this situation.

Additionally, you can use `@SpyBean` to wrap any existing bean with a Mockito `spy`.
See the {spring-boot-test-module-api}/mock/mockito/SpyBean.html[Javadoc] for full details.

NOTE: CGLib proxies, such as those created for scoped beans, declare the proxied methods as `final`.
This stops Mockito from functioning correctly as it cannot mock or spy on `final` methods in its default configuration.
If you want to mock or spy on such a bean, configure Mockito to use its inline mock maker by adding `org.mockito:mockito-inline` to your application's test dependencies.
This allows Mockito to mock and spy on `final` methods.

NOTE: While Spring's test framework caches application contexts between tests and reuses a context for tests sharing the same configuration, the use of `@MockBean` or `@SpyBean` influences the cache key, which will most likely increase the number of contexts.

TIP: If you are using `@SpyBean` to spy on a bean with `@Cacheable` methods that refer to parameters by name, your application must be compiled with `-parameters`.
This ensures that the parameter names are available to the caching infrastructure once the bean has been spied upon.

TIP: When you are using `@SpyBean` to spy on a bean that is proxied by Spring, you may need to remove Spring's proxy in some situations, for example when setting expectations using `given` or `when`.
Use `AopTestUtils.getTargetObject(yourProxiedSpy)` to do so.



[[features.testing.spring-boot-applications.autoconfigured-tests]]
==== Auto-configured Tests
Spring Boot's auto-configuration system works well for applications but can sometimes be a little too much for tests.
It often helps to load only the parts of the configuration that are required to test a ""`slice`"" of your application.
For example, you might want to test that Spring MVC controllers are mapping URLs correctly, and you do not want to involve database calls in those tests, or you might want to test JPA entities, and you are not interested in the web layer when those tests run.

The `spring-boot-test-autoconfigure` module includes a number of annotations that can be used to automatically configure such ""`slices`"".
Each of them works in a similar way, providing a `@...Test` annotation that loads the `ApplicationContext` and one or more `@AutoConfigure...` annotations that can be used to customize auto-configuration settings.

NOTE: Each slice restricts component scan to appropriate components and loads a very restricted set of auto-configuration classes.
If you need to exclude one of them, most `@...Test` annotations provide an `excludeAutoConfiguration` attribute.
Alternatively, you can use `@ImportAutoConfiguration#exclude`.

NOTE: Including multiple ""`slices`"" by using several `@...Test` annotations in one test is not supported.
If you need multiple ""`slices`"", pick one of the `@...Test` annotations and include the `@AutoConfigure...` annotations of the other ""`slices`"" by hand.

TIP: It is also possible to use the `@AutoConfigure...` annotations with the standard `@SpringBootTest` annotation.
You can use this combination if you are not interested in ""`slicing`"" your application but you want some of the auto-configured test beans.



[[features.testing.spring-boot-applications.json-tests]]
==== Auto-configured JSON Tests
To test that object JSON serialization and deserialization is working as expected, you can use the `@JsonTest` annotation.
`@JsonTest` auto-configures the available supported JSON mapper, which can be one of the following libraries:

* Jackson `ObjectMapper`, any `@JsonComponent` beans and any Jackson ``Module``s
* `Gson`
* `Jsonb`

TIP: A list of the auto-configurations that are enabled by `@JsonTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

If you need to configure elements of the auto-configuration, you can use the `@AutoConfigureJsonTesters` annotation.

Spring Boot includes AssertJ-based helpers that work with the JSONAssert and JsonPath libraries to check that JSON appears as expected.
The `JacksonTester`, `GsonTester`, `JsonbTester`, and `BasicJsonTester` classes can be used for Jackson, Gson, Jsonb, and Strings respectively.
Any helper fields on the test class can be `@Autowired` when using `@JsonTest`.
The following example shows a test class for Jackson:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/jsontests/MyJsonTests.java[]
----

NOTE: JSON helper classes can also be used directly in standard unit tests.
To do so, call the `initFields` method of the helper in your `@Before` method if you do not use `@JsonTest`.

If you're using Spring Boot's AssertJ-based helpers to assert on a number value at a given JSON path, you might not be able to use `isEqualTo` depending on the type.
Instead, you can use AssertJ's `satisfies` to assert that the value matches the given condition.
For instance, the following example asserts that the actual number is a float value close to `0.15` within an offset of `0.01`.

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/jsontests/MyJsonAssertJTests.java[tag=*]
----



[[features.testing.spring-boot-applications.spring-mvc-tests]]
==== Auto-configured Spring MVC Tests
To test whether Spring MVC controllers are working as expected, use the `@WebMvcTest` annotation.
`@WebMvcTest` auto-configures the Spring MVC infrastructure and limits scanned beans to `@Controller`, `@ControllerAdvice`, `@JsonComponent`, `Converter`, `GenericConverter`, `Filter`, `HandlerInterceptor`, `WebMvcConfigurer`, and `HandlerMethodArgumentResolver`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@WebMvcTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configuration settings that are enabled by `@WebMvcTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

TIP: If you need to register extra components, such as the Jackson `Module`, you can import additional configuration classes by using `@Import` on your test.

Often, `@WebMvcTest` is limited to a single controller and is used in combination with `@MockBean` to provide mock implementations for required collaborators.

`@WebMvcTest` also auto-configures `MockMvc`.
Mock MVC offers a powerful way to quickly test MVC controllers without needing to start a full HTTP server.

TIP: You can also auto-configure `MockMvc` in a non-`@WebMvcTest` (such as `@SpringBootTest`) by annotating it with `@AutoConfigureMockMvc`.
The following example uses `MockMvc`:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/springmvctests/MyControllerTests.java[]
----

TIP: If you need to configure elements of the auto-configuration (for example, when servlet filters should be applied) you can use attributes in the `@AutoConfigureMockMvc` annotation.

If you use HtmlUnit or Selenium, auto-configuration also provides an HtmlUnit `WebClient` bean and/or a Selenium `WebDriver` bean.
The following example uses HtmlUnit:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/springmvctests/MyHtmlUnitTests.java[]
----

NOTE: By default, Spring Boot puts `WebDriver` beans in a special ""`scope`"" to ensure that the driver exits after each test and that a new instance is injected.
If you do not want this behavior, you can add `@Scope(""singleton"")` to your `WebDriver` `@Bean` definition.

WARNING: The `webDriver` scope created by Spring Boot will replace any user defined scope of the same name.
If you define your own `webDriver` scope you may find it stops working when you use `@WebMvcTest`.

If you have Spring Security on the classpath, `@WebMvcTest` will also scan `WebSecurityConfigurer` beans.
Instead of disabling security completely for such tests, you can use Spring Security's test support.
More details on how to use Spring Security's `MockMvc` support can be found in this _<<howto#howto.testing.with-spring-security>>_ how-to section.

TIP: Sometimes writing Spring MVC tests is not enough; Spring Boot can help you run <<features#features.testing.spring-boot-applications.with-running-server, full end-to-end tests with an actual server>>.



[[features.testing.spring-boot-applications.spring-webflux-tests]]
==== Auto-configured Spring WebFlux Tests
To test that {spring-framework-docs}/web-reactive.html[Spring WebFlux] controllers are working as expected, you can use the `@WebFluxTest` annotation.
`@WebFluxTest` auto-configures the Spring WebFlux infrastructure and limits scanned beans to `@Controller`, `@ControllerAdvice`, `@JsonComponent`, `Converter`, `GenericConverter`, `WebFilter`, and `WebFluxConfigurer`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@WebFluxTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@WebFluxTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

TIP: If you need to register extra components, such as Jackson `Module`, you can import additional configuration classes using `@Import` on your test.

Often, `@WebFluxTest` is limited to a single controller and used in combination with the `@MockBean` annotation to provide mock implementations for required collaborators.

`@WebFluxTest` also auto-configures {spring-framework-docs}/testing.html#webtestclient[`WebTestClient`], which offers a powerful way to quickly test WebFlux controllers without needing to start a full HTTP server.

TIP: You can also auto-configure `WebTestClient` in a non-`@WebFluxTest` (such as `@SpringBootTest`) by annotating it with `@AutoConfigureWebTestClient`.
The following example shows a class that uses both `@WebFluxTest` and a `WebTestClient`:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/springwebfluxtests/MyControllerTests.java[]
----

TIP: This setup is only supported by WebFlux applications as using `WebTestClient` in a mocked web application only works with WebFlux at the moment.

NOTE: `@WebFluxTest` cannot detect routes registered via the functional web framework.
For testing `RouterFunction` beans in the context, consider importing your `RouterFunction` yourself via `@Import` or using `@SpringBootTest`.

NOTE: `@WebFluxTest` cannot detect custom security configuration registered via a `@Bean` of type `SecurityWebFilterChain`.
To include that in your test, you will need to import the configuration that registers the bean via `@Import` or use `@SpringBootTest`.

TIP: Sometimes writing Spring WebFlux tests is not enough; Spring Boot can help you run <<features#features.testing.spring-boot-applications.with-running-server, full end-to-end tests with an actual server>>.



[[features.testing.spring-boot-applications.autoconfigured-spring-data-cassandra]]
==== Auto-configured Data Cassandra Tests
You can use `@DataCassandraTest` to test Cassandra applications.
By default, it configures a `CassandraTemplate`, scans for `@Table` classes, and configures Spring Data Cassandra repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataCassandraTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using Cassandra with Spring Boot, see ""<<features#features.nosql.cassandra>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataCassandraTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows a typical setup for using Cassandra tests in Spring Boot:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatacassandra/MyDataCassandraTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-data-jpa]]
==== Auto-configured Data JPA Tests
You can use the `@DataJpaTest` annotation to test JPA applications.
By default, it scans for `@Entity` classes and configures Spring Data JPA repositories.
If an embedded database is available on the classpath, it configures one as well.
SQL queries are logged by default by setting the `spring.jpa.show-sql` property to `true`.
This can be disabled using the `showSql()` attribute of the annotation.

Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataJpaTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configuration settings that are enabled by `@DataJpaTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

By default, data JPA tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole class as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatajpa/MyNonTransactionalTests.java[]
----

Data JPA tests may also inject a {spring-boot-test-autoconfigure-module-code}/orm/jpa/TestEntityManager.java[`TestEntityManager`] bean, which provides an alternative to the standard JPA `EntityManager` that is specifically designed for tests.
If you want to use `TestEntityManager` outside of `@DataJpaTest` instances, you can also use the `@AutoConfigureTestEntityManager` annotation.
A `JdbcTemplate` is also available if you need that.
The following example shows the `@DataJpaTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatajpa/withoutdb/MyRepositoryTests.java[]
----

In-memory embedded databases generally work well for tests, since they are fast and do not require any installation.
If, however, you prefer to run tests against a real database you can use the `@AutoConfigureTestDatabase` annotation, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatajpa/withdb/MyRepositoryTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-jdbc]]
==== Auto-configured JDBC Tests
`@JdbcTest` is similar to `@DataJpaTest` but is for tests that only require a `DataSource` and do not use Spring Data JDBC.
By default, it configures an in-memory embedded database and a `JdbcTemplate`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@JdbcTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@JdbcTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

By default, JDBC tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole class, as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredjdbc/MyTransactionalTests.java[]
----

If you prefer your test to run against a real database, you can use the `@AutoConfigureTestDatabase` annotation in the same way as for `DataJpaTest`.
(See ""<<features#features.testing.spring-boot-applications.autoconfigured-spring-data-jpa>>"".)



[[features.testing.spring-boot-applications.autoconfigured-spring-data-jdbc]]
==== Auto-configured Data JDBC Tests
`@DataJdbcTest` is similar to `@JdbcTest` but is for tests that use Spring Data JDBC repositories.
By default, it configures an in-memory embedded database, a `JdbcTemplate`, and Spring Data JDBC repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataJdbcTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@DataJdbcTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

By default, Data JDBC tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole test class as <<features#features.testing.spring-boot-applications.autoconfigured-jdbc,shown in the JDBC example>>.

If you prefer your test to run against a real database, you can use the `@AutoConfigureTestDatabase` annotation in the same way as for `DataJpaTest`.
(See ""<<features#features.testing.spring-boot-applications.autoconfigured-spring-data-jpa>>"".)



[[features.testing.spring-boot-applications.autoconfigured-jooq]]
==== Auto-configured jOOQ Tests
You can use `@JooqTest` in a similar fashion as `@JdbcTest` but for jOOQ-related tests.
As jOOQ relies heavily on a Java-based schema that corresponds with the database schema, the existing `DataSource` is used.
If you want to replace it with an in-memory database, you can use `@AutoConfigureTestDatabase` to override those settings.
(For more about using jOOQ with Spring Boot, see ""<<features#features.sql.jooq>>"", earlier in this chapter.)
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@JooqTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@JooqTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

`@JooqTest` configures a `DSLContext`.
The following example shows the `@JooqTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredjooq/MyJooqTests.java[]
----

JOOQ tests are transactional and roll back at the end of each test by default.
If that is not what you want, you can disable transaction management for a test or for the whole test class as <<features#features.testing.spring-boot-applications.autoconfigured-jdbc,shown in the JDBC example>>.



[[features.testing.spring-boot-applications.autoconfigured-spring-data-mongodb]]
==== Auto-configured Data MongoDB Tests
You can use `@DataMongoTest` to test MongoDB applications.
By default, it configures an in-memory embedded MongoDB (if available), configures a `MongoTemplate`, scans for `@Document` classes, and configures Spring Data MongoDB repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataMongoTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using MongoDB with Spring Boot, see ""<<features#features.nosql.mongodb>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataMongoTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following class shows the `@DataMongoTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatamongodb/withoutdb/MyDataMongoDbTests.java[]
----

In-memory embedded MongoDB generally works well for tests, since it is fast and does not require any developer installation.
If, however, you prefer to run tests against a real MongoDB server, you should exclude the embedded MongoDB auto-configuration, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatamongodb/withdb/MyDataMongoDbTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-data-neo4j]]
==== Auto-configured Data Neo4j Tests
You can use `@DataNeo4jTest` to test Neo4j applications.
By default, it scans for `@Node` classes, and configures Spring Data Neo4j repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataNeo4jTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using Neo4J with Spring Boot, see ""<<features#features.nosql.neo4j>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataNeo4jTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows a typical setup for using Neo4J tests in Spring Boot:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataneo4j/propagation/MyDataNeo4jTests.java[]
----

By default, Data Neo4j tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole class, as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataneo4j/nopropagation/MyDataNeo4jTests.java[]
----

NOTE: Transactional tests are not supported with reactive access.
If you are using this style, you must configure `@DataNeo4jTest` tests as described above.



[[features.testing.spring-boot-applications.autoconfigured-spring-data-redis]]
==== Auto-configured Data Redis Tests
You can use `@DataRedisTest` to test Redis applications.
By default, it scans for `@RedisHash` classes and configures Spring Data Redis repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataRedisTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using Redis with Spring Boot, see ""<<features#features.nosql.redis>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataRedisTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows the `@DataRedisTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataredis/MyDataRedisTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-data-ldap]]
==== Auto-configured Data LDAP Tests
You can use `@DataLdapTest` to test LDAP applications.
By default, it configures an in-memory embedded LDAP (if available), configures an `LdapTemplate`, scans for `@Entry` classes, and configures Spring Data LDAP repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataLdapTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using LDAP with Spring Boot, see ""<<features#features.nosql.ldap>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataLdapTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows the `@DataLdapTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataldap/inmemory/MyDataLdapTests.java[]
----

In-memory embedded LDAP generally works well for tests, since it is fast and does not require any developer installation.
If, however, you prefer to run tests against a real LDAP server, you should exclude the embedded LDAP auto-configuration, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataldap/server/MyDataLdapTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-rest-client]]
==== Auto-configured REST Clients
You can use the `@RestClientTest` annotation to test REST clients.
By default, it auto-configures Jackson, GSON, and Jsonb support, configures a `RestTemplateBuilder`, and adds support for `MockRestServiceServer`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@RestClientTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configuration settings that are enabled by `@RestClientTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The specific beans that you want to test should be specified by using the `value` or `components` attribute of `@RestClientTest`, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredrestclient/MyRestClientTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs]]
==== Auto-configured Spring REST Docs Tests
You can use the `@AutoConfigureRestDocs` annotation to use {spring-restdocs}[Spring REST Docs] in your tests with Mock MVC, REST Assured, or WebTestClient.
It removes the need for the JUnit extension in Spring REST Docs.

`@AutoConfigureRestDocs` can be used to override the default output directory (`target/generated-snippets` if you are using Maven or `build/generated-snippets` if you are using Gradle).
It can also be used to configure the host, scheme, and port that appears in any documented URIs.



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-mock-mvc]]
===== Auto-configured Spring REST Docs Tests with Mock MVC
`@AutoConfigureRestDocs` customizes the `MockMvc` bean to use Spring REST Docs when testing Servlet-based web applications.
You can inject it by using `@Autowired` and use it in your tests as you normally would when using Mock MVC and Spring REST Docs, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withmockmvc/MyUserDocumentationTests.java[]
----

If you require more control over Spring REST Docs configuration than offered by the attributes of `@AutoConfigureRestDocs`, you can use a `RestDocsMockMvcConfigurationCustomizer` bean, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withmockmvc/MyRestDocsConfiguration.java[]
----

If you want to make use of Spring REST Docs support for a parameterized output directory, you can create a `RestDocumentationResultHandler` bean.
The auto-configuration calls `alwaysDo` with this result handler, thereby causing each `MockMvc` call to automatically generate the default snippets.
The following example shows a `RestDocumentationResultHandler` being defined:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withmockmvc/MyResultHandlerConfiguration.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-web-test-client]]
===== Auto-configured Spring REST Docs Tests with WebTestClient
`@AutoConfigureRestDocs` can also be used with `WebTestClient` when testing reactive web applications.
You can inject it by using `@Autowired` and use it in your tests as you normally would when using `@WebFluxTest` and Spring REST Docs, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withwebtestclient/MyUsersDocumentationTests.java[]
----

If you require more control over Spring REST Docs configuration than offered by the attributes of `@AutoConfigureRestDocs`, you can use a `RestDocsWebTestClientConfigurationCustomizer` bean, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withwebtestclient/MyRestDocsConfiguration.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-rest-assured]]
===== Auto-configured Spring REST Docs Tests with REST Assured
`@AutoConfigureRestDocs` makes a `RequestSpecification` bean, preconfigured to use Spring REST Docs, available to your tests.
You can inject it by using `@Autowired` and use it in your tests as you normally would when using REST Assured and Spring REST Docs, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withrestassured/MyUserDocumentationTests.java[]
----

If you require more control over Spring REST Docs configuration than offered by the attributes of `@AutoConfigureRestDocs`, a `RestDocsRestAssuredConfigurationCustomizer` bean can be used, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withrestassured/MyRestDocsConfiguration.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-webservices]]
==== Auto-configured Spring Web Services Tests
You can use `@WebServiceClientTest` to test applications that use call web services using the Spring Web Services project.
By default, it configures a mock `WebServiceServer` bean and automatically customizes your `WebServiceTemplateBuilder`.
(For more about using Web Services with Spring Boot, see ""<<features#features.webservices>>"", earlier in this chapter.)


TIP: A list of the auto-configuration settings that are enabled by `@WebServiceClientTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows the `@WebServiceClientTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredwebservices/MyWebServiceClientTests.java[]
----



[[features.testing.spring-boot-applications.additional-autoconfiguration-and-slicing]]
==== Additional Auto-configuration and Slicing
Each slice provides one or more `@AutoConfigure...` annotations that namely defines the auto-configurations that should be included as part of a slice.
Additional auto-configurations can be added on a test-by-test basis by creating a custom `@AutoConfigure...` annotation or by adding `@ImportAutoConfiguration` to the test as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/additionalautoconfigurationandslicing/MyJdbcTests.java[]
----

NOTE: Make sure to not use the regular `@Import` annotation to import auto-configurations as they are handled in a specific way by Spring Boot.

Alternatively, additional auto-configurations can be added for any use of a slice annotation by registering them in `META-INF/spring.factories` as shown in the following example:

[indent=0]
----
	org.springframework.boot.test.autoconfigure.jdbc.JdbcTest=com.example.IntegrationAutoConfiguration
----

TIP: A slice or `@AutoConfigure...` annotation can be customized this way as long as it is meta-annotated with `@ImportAutoConfiguration`.



[[features.testing.spring-boot-applications.user-configuration-and-slicing]]
==== User Configuration and Slicing
If you <<using#using.structuring-your-code, structure your code>> in a sensible way, your `@SpringBootApplication` class is <<features#features.testing.spring-boot-applications.detecting-configuration, used by default>> as the configuration of your tests.

It then becomes important not to litter the application's main class with configuration settings that are specific to a particular area of its functionality.

Assume that you are using Spring Batch and you rely on the auto-configuration for it.
You could define your `@SpringBootApplication` as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyApplication.java[]
----

Because this class is the source configuration for the test, any slice test actually tries to start Spring Batch, which is definitely not what you want to do.
A recommended approach is to move that area-specific configuration to a separate `@Configuration` class at the same level as your application, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyBatchConfiguration.java[]
----

NOTE: Depending on the complexity of your application, you may either have a single `@Configuration` class for your customizations or one class per domain area.
The latter approach lets you enable it in one of your tests, if necessary, with the `@Import` annotation.

Test slices exclude `@Configuration` classes from scanning.
For example, for a `@WebMvcTest`, the following configuration will not include the given `WebMvcConfigurer` bean in the application context loaded by the test slice:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyWebConfiguration.java[]
----

The configuration below will, however, cause the custom `WebMvcConfigurer` to be loaded by the test slice.

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyWebMvcConfigurer.java[]
----

Another source of confusion is classpath scanning.
Assume that, while you structured your code in a sensible way, you need to scan an additional package.
Your application may resemble the following code:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/scan/MyApplication.java[]
----

Doing so effectively overrides the default component scan directive with the side effect of scanning those two packages regardless of the slice that you chose.
For instance, a `@DataJpaTest` seems to suddenly scan components and user configurations of your application.
Again, moving the custom directive to a separate class is a good way to fix this issue.

TIP: If this is not an option for you, you can create a `@SpringBootConfiguration` somewhere in the hierarchy of your test so that it is used instead.
Alternatively, you can specify a source for your test, which disables the behavior of finding a default one.



[[features.testing.spring-boot-applications.spock]]
==== Using Spock to Test Spring Boot Applications
Spock 2.x can be used to test a Spring Boot application.
To do so, add a dependency on Spock's `spock-spring` module to your application's build.
`spock-spring` integrates Spring's test framework into Spock.
See https://spockframework.org/spock/docs/2.0/modules.html#_spring_module[the documentation for Spock's Spring module] for further details.



[[features.testing.utilities]]
=== Test Utilities
A few test utility classes that are generally useful when testing your application are packaged as part of `spring-boot`.



[[features.testing.utilities.config-data-application-context-initializer]]
==== ConfigDataApplicationContextInitializer
`ConfigDataApplicationContextInitializer` is an `ApplicationContextInitializer` that you can apply to your tests to load Spring Boot `application.properties` files.
You can use it when you do not need the full set of features provided by `@SpringBootTest`, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/configdataapplicationcontextinitializer/MyConfigFileTests.java[]
----

NOTE: Using `ConfigDataApplicationContextInitializer` alone does not provide support for `@Value(""${...}"")` injection.
Its only job is to ensure that `application.properties` files are loaded into Spring's `Environment`.
For `@Value` support, you need to either additionally configure a `PropertySourcesPlaceholderConfigurer` or use `@SpringBootTest`, which auto-configures one for you.



[[features.testing.utilities.test-property-values]]
==== TestPropertyValues
`TestPropertyValues` lets you quickly add properties to a `ConfigurableEnvironment` or `ConfigurableApplicationContext`.
You can call it with `key=value` strings, as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/testpropertyvalues/MyEnvironmentTests.java[]
----



[[features.testing.utilities.output-capture]]
==== OutputCapture
`OutputCapture` is a JUnit `Extension` that you can use to capture `System.out` and `System.err` output.
To use add `@ExtendWith(OutputCaptureExtension.class)` and inject `CapturedOutput` as an argument to your test class constructor or test method as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/outputcapture/MyOutputCaptureTests.java[]
----



[[features.testing.utilities.test-rest-template]]
==== TestRestTemplate
`TestRestTemplate` is a convenience alternative to Spring's `RestTemplate` that is useful in integration tests.
You can get a vanilla template or one that sends Basic HTTP authentication (with a username and password).
In either case, the template is fault tolerant.
This means that it behaves in a test-friendly way by not throwing exceptions on 4xx and 5xx errors.
Instead, such errors can be detected via the returned `ResponseEntity` and its status code.

TIP: Spring Framework 5.0 provides a new `WebTestClient` that works for <<features#features.testing.spring-boot-applications.spring-webflux-tests, WebFlux integration tests>> and both <<features#features.testing.spring-boot-applications.with-running-server, WebFlux and MVC end-to-end testing>>.
It provides a fluent API for assertions, unlike `TestRestTemplate`.

It is recommended, but not mandatory, to use the Apache HTTP Client (version 4.3.2 or better).
If you have that on your classpath, the `TestRestTemplate` responds by configuring the client appropriately.
If you do use Apache's HTTP client, some additional test-friendly features are enabled:

* Redirects are not followed (so you can assert the response location).
* Cookies are ignored (so the template is stateless).

`TestRestTemplate` can be instantiated directly in your integration tests, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/testresttemplate/MyTests.java[]
----

Alternatively, if you use the `@SpringBootTest` annotation with `WebEnvironment.RANDOM_PORT` or `WebEnvironment.DEFINED_PORT`, you can inject a fully configured `TestRestTemplate` and start using it.
If necessary, additional customizations can be applied through the `RestTemplateBuilder` bean.
Any URLs that do not specify a host and port automatically connect to the embedded server, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/testresttemplate/MySpringBootTests.java[]
----
",12345,True,2619.4643198948056,median
"// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#include ""stdafx.h""
#include ""test_utils.h""
#include ""test_websocket_client.h""
#include ""connection_impl.h""
#include ""signalrclient/trace_level.h""
#include ""memory_log_writer.h""
#include ""signalr_default_scheduler.h""
#include ""signalrclient/signalr_exception.h""
#include ""signalrclient/web_exception.h""
#include ""test_http_client.h""

using namespace signalr;

static std::shared_ptr<connection_impl> create_connection(std::shared_ptr<test_websocket_client> websocket_client = create_test_websocket_client(),
    std::shared_ptr<log_writer> log_writer = std::make_shared<memory_log_writer>(), trace_level trace_level = trace_level::verbose)
{
    return connection_impl::create(create_uri(), trace_level, log_writer, create_test_http_client(),
        [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });
}

TEST(connection_impl_connection_state, initial_connection_state_is_disconnected)
{
    auto connection = create_connection();

    ASSERT_EQ(connection_state::disconnected, connection->get_connection_state());
}

TEST(connection_impl_start, cannot_start_non_disconnected_exception)
{
    auto connection = create_connection();

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    try
    {
        connection->start([&mre](std::exception_ptr exception)
            {
                mre.set(exception);
            });
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(""cannot start a connection that is not in the disconnected state"", e.what());
    }
}

TEST(connection_impl_start, connection_state_is_connecting_when_connection_is_being_started)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto state_mre = manual_reset_event<void>();
    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked""))); },
        /* connect function */[&state_mre](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            state_mre.get();
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto connection = create_connection(websocket_client, writer, trace_level::error);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    ASSERT_EQ(connection->get_connection_state(), connection_state::connecting);
    state_mre.set();

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::runtime_error & ex)
    {
        ASSERT_STREQ(""connecting failed"", ex.what());
    }
}

TEST(connection_impl_start, connection_state_is_connected_when_connection_established_succesfully)
{
    auto connection = create_connection();
    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });
    mre.get();
    ASSERT_EQ(connection->get_connection_state(), connection_state::connected);
}

TEST(connection_impl_start, connection_state_is_disconnected_when_connection_cannot_be_established)
{
    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string&, http_request)
        {
            return http_response{ 404, """" };
        }));

    auto connection =
        connection_impl::create(create_uri(), trace_level::none, std::make_shared<memory_log_writer>(),
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, nullptr);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (...) {}

    ASSERT_EQ(connection->get_connection_state(), connection_state::disconnected);
}

TEST(connection_impl_start, throws_for_invalid_uri)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto websocket_client = create_test_websocket_client();

    auto connection = connection_impl::create("":1\\t ä bad_uri&a=b"", trace_level::error, writer, create_test_http_client(),
        [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::exception&)
    {
        // We shouldn't check the exact exception as it would be specific to the http library being used
    }

    ASSERT_EQ(connection->get_connection_state(), connection_state::disconnected);
}

TEST(connection_impl_start, start_sets_id_query_string)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    std::string query_string;

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked"")));  },
        /* connect function */[&query_string](const std::string& url, std::function<void(std::exception_ptr)> callback)
        {
            query_string = url.substr(url.find('?') + 1);
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto connection = connection_impl::create(create_uri(""""), trace_level::error, writer, create_test_http_client(),
        [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::runtime_error & ex)
    {
        ASSERT_STREQ(""connecting failed"", ex.what());
    }

    ASSERT_EQ(""id=f7707523-307d-4cba-9abf-3eef701241e8"", query_string);
}

TEST(connection_impl_start, start_appends_id_query_string)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    std::string query_string;

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked"")));  },
        /* connect function */[&query_string](const std::string& url, std::function<void(std::exception_ptr)> callback)
        {
            query_string = url.substr(url.find('?') + 1);
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto connection = connection_impl::create(create_uri(""a=b&c=d""), trace_level::error,
        writer, create_test_http_client(), [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::runtime_error & ex)
    {
        ASSERT_STREQ(""connecting failed"", ex.what());
    }

    ASSERT_EQ(""a=b&c=d&id=f7707523-307d-4cba-9abf-3eef701241e8"", query_string);
}

TEST(connection_impl_start, start_logs_exceptions)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string&, http_request)
        {
            return http_response{ 404, """" };
        }));

    auto connection =
        connection_impl::create(create_uri(), trace_level::error, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, nullptr);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (...) {}

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_FALSE(log_entries.empty());

    ASSERT_TRUE(has_log_entry(""[error    ] connection could not be started due to: negotiate failed with status code 404\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_start, start_propagates_exceptions_from_negotiate)
{
    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string&, http_request) -> http_response
        {
            throw custom_exception();
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::none,
            std::make_shared<memory_log_writer>(), [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const custom_exception& e)
    {
        ASSERT_STREQ(""custom exception"", e.what());
    }
}

TEST(connection_impl_start, start_fails_if_transport_connect_throws)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked"")));  },
        /* connect function */[](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto connection = create_connection(websocket_client, writer, trace_level::error);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const std::exception & e)
    {
        ASSERT_STREQ(""connecting failed"", e.what());
    }

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_TRUE(log_entries.size() > 1) << dump_vector(log_entries);

    ASSERT_TRUE(has_log_entry(""[error    ] transport could not connect due to: connecting failed\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_send, send_fails_if_transport_fails_when_receiving_messages)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            callback(std::make_exception_ptr(std::runtime_error(""send error"")));
        });

    auto connection = create_connection(websocket_client, writer, trace_level::error);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->send(""message"", transfer_format::text, [&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const std::exception & e)
    {
        ASSERT_STREQ(""send error"", e.what());
    }

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();

    ASSERT_TRUE(has_log_entry(""[error    ] error sending data: send error\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_start, start_fails_if_negotiate_request_fails)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string&, http_request)
        {
            return http_response{ 400, """" };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const std::exception & e)
    {
        ASSERT_STREQ(""negotiate failed with status code 400"", e.what());
    }
}

TEST(connection_impl_start, start_fails_if_negotiate_response_has_error)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{ \\""error\\"": \\""bad negotiate\\"" }""
                : """";

            return http_response{ 200, response_body };
        }));

    auto connect_mre = manual_reset_event<void>();
    auto websocket_client = std::make_shared<test_websocket_client>();
    websocket_client->set_connect_function([&connect_mre](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            connect_mre.get();
            callback(nullptr);
        });

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(""bad negotiate"", e.what());
    }

    connect_mre.set();
}

TEST(connection_impl_start, start_fails_if_negotiate_response_does_not_have_websockets)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{ \\""availableTransports\\"": [ { \\""transport\\"": \\""ServerSentEvents\\"", \\""transferFormats\\"": [ \\""Text\\"" ] } ] }""
                : """";

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(""The server does not support WebSockets which is currently the only transport supported by this client."", e.what());
    }
}

TEST(connection_impl_start, start_fails_if_negotiate_response_does_not_have_transports)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{ \\""availableTransports\\"": [ ] }""
                : """";

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(""The server does not support WebSockets which is currently the only transport supported by this client."", e.what());
    }
}

TEST(connection_impl_start, start_fails_if_negotiate_response_is_invalid)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{ \\""availableTransports\\"": [ ""
                : """";

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const std::runtime_error&) { }
}

TEST(connection_impl_start, negotiate_follows_redirect)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                if (url.find(""redirected"") != std::string::npos)
                {
                    response_body = ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                        ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }"";
                }
                else
                {
                    response_body = ""{ \\""url\\"": \\""http://redirected\\"" }"";
                }
            }

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    std::string connectUrl;
    websocket_client->set_connect_function([&connectUrl](const std::string& url, std::function<void(std::exception_ptr)> callback)
        {
            connectUrl = url;
            callback(nullptr);
        });

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_EQ(""ws://redirected/?id=f7707523-307d-4cba-9abf-3eef701241e8"", connectUrl);
}

TEST(connection_impl_start, negotiate_redirect_uses_accessToken)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    std::string accessToken;

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([&accessToken](const std::string& url, http_request request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                if (url.find(""redirected"") != std::string::npos)
                {
                    response_body = ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                        ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }"";
                }
                else
                {
                    response_body = ""{ \\""url\\"": \\""http://redirected\\"", \\""accessToken\\"": \\""secret\\"" }"";
                }
            }

            accessToken = request.headers[""Authorization""];
            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    std::string connectUrl;
    websocket_client->set_connect_function([&connectUrl](const std::string& url, std::function<void(std::exception_ptr)> callback)
        {
            connectUrl = url;
            callback(nullptr);
        });

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_EQ(""ws://redirected/?id=f7707523-307d-4cba-9abf-3eef701241e8"", connectUrl);
    ASSERT_EQ(""Bearer secret"", accessToken);
}

TEST(connection_impl_start, negotiate_fails_after_too_many_redirects)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                // infinite redirect
                response_body = ""{ \\""url\\"": \\""http://redirected\\"" }"";
            }

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (signalr_exception e)
    {
        ASSERT_STREQ(""Negotiate redirection limit exceeded."", e.what());
    }
}

TEST(connection_impl_start, negotiate_fails_if_ProtocolVersion_in_response)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                response_body = ""{\\""ProtocolVersion\\"" : \\""\\"" }"";
            }

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config&) { return websocket_client; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
    }
    catch (signalr_exception e)
    {
        ASSERT_STREQ(""Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details."", e.what());
    }
}

TEST(connection_impl_start, negotiate_redirect_does_not_overwrite_url)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    int redirectCount = 0;

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([&redirectCount](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                if (url.find(""redirected"") != std::string::npos)
                {
                    response_body = ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                        ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }"";
                }
                else
                {
                    response_body = ""{ \\""url\\"": \\""http://redirected\\"" }"";
                    redirectCount++;
                }
            }

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });
    mre.get();
    ASSERT_EQ(1, redirectCount);

    connection->stop([&mre](std::exception_ptr)
        {
            mre.set();
        }, nullptr);
    mre.get();

    connection->start([&mre](std::exception_ptr)
        {
            mre.set();
        });
    mre.get();
    ASSERT_EQ(2, redirectCount);
}

TEST(connection_impl_start, negotiate_redirect_uses_own_query_string)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    std::string query_string;

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked""))); },
        /* connect function */[&query_string](const std::string& url, std::function<void(std::exception_ptr)> callback)
        {
            query_string = url.substr(url.find('?') + 1);
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                if (url.find(""redirected"") != std::string::npos)
                {
                    response_body = ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                        ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }"";
                }
                else
                {
                    response_body = ""{ \\""url\\"": \\""http://redirected?customQuery=1\\"" }"";
                }
            }

            return http_response{ 200, response_body };
        }));

    auto connection = connection_impl::create(create_uri(""a=b&c=d""), trace_level::error, writer,
        [http_client](const signalr_client_config& config) {
            http_client->set_scheduler(config.get_scheduler());
            return http_client;
        }, [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::runtime_error & ex)
    {
        ASSERT_STREQ(""connecting failed"", ex.what());
    }

    ASSERT_EQ(""customQuery=1&id=f7707523-307d-4cba-9abf-3eef701241e8"", query_string);
}

TEST(connection_impl_start, negotiate_with_negotiateVersion_uses_connectionToken)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    std::string query_string;

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked""))); },
        /* connect function */[&query_string](const std::string& url, std::function<void(std::exception_ptr)> callback)
        {
            query_string = url.substr(url.find('?') + 1);
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                response_body = ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                    ""\\""connectionToken\\"":\\""1122334455\\"", \\""negotiateVersion\\"": 1, ""
                    ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }"";
            }

            return http_response{ 200, response_body };
        }));

    auto connection = connection_impl::create(create_uri(), trace_level::error, writer,
        [http_client](const signalr_client_config& config) {
            http_client->set_scheduler(config.get_scheduler());
            return http_client;
        }, [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::runtime_error & ex)
    {
        ASSERT_STREQ(""connecting failed"", ex.what());
    }

    ASSERT_EQ(""id=1122334455"", query_string);
}

TEST(connection_impl_start, correct_connection_id_returned_with_negotiateVersion_one)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked""))); },
        /* connect function */[](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            callback(nullptr);
        });

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            std::string response_body = """";
            if (url.find(""/negotiate"") != std::string::npos)
            {
                response_body = ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                    ""\\""connectionToken\\"":\\""1122334455\\"", \\""negotiateVersion\\"": 1, ""
                    ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }"";
            }

            return http_response{ 200, response_body };
        }));

    auto connection = connection_impl::create(create_uri(), trace_level::error, writer,
        [http_client](const signalr_client_config& config) {
            http_client->set_scheduler(config.get_scheduler());
            return http_client;
        }, [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_EQ(""f7707523-307d-4cba-9abf-3eef701241e8"", connection->get_connection_id());
}

TEST(connection_impl_start, start_fails_if_connect_request_times_out)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto http_client = create_test_http_client();

    auto connect_mre = manual_reset_event<void>();
    auto wait_connect_mre = manual_reset_event<void>();
    auto websocket_client = std::make_shared<test_websocket_client>();
    websocket_client->set_connect_function([&connect_mre, &wait_connect_mre](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            connect_mre.get();
            callback(nullptr);
            wait_connect_mre.set();
        });

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            std::move(http_client), [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(""transport timed out when trying to connect"", e.what());
    }

    connect_mre.set();
    wait_connect_mre.get();
}

TEST(connection_impl_start, negotiate_can_be_skipped)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    bool negotiate_called = false;

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([&negotiate_called](const std::string& url, http_request request)
        {
            negotiate_called = true;

            auto response_body =
                url.find_first_of(""/negotiate"") != 0
                ? ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }""
                : """";

            return http_response{ 200, response_body };
        }));

    auto websocket_client = std::make_shared<test_websocket_client>();

    auto connection =
        connection_impl::create(create_uri(), trace_level::info, writer,
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            }, true);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_TRUE(connection->get_connection_state() == connection_state::connected);
    ASSERT_TRUE(connection->get_connection_id().empty());
    ASSERT_FALSE(negotiate_called);
}

TEST(connection_impl_process_response, process_response_logs_messages)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    auto wait_receive = std::make_shared<cancellation_token>();
    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::debug);

    auto message_mre = manual_reset_event<std::string>();
    connection->set_message_received([&message_mre](std::string&& message)
        {
            message_mre.set(message);
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_FALSE(websocket_client->receive_loop_started.wait(1000));
    websocket_client->receive_message(""{ }"");

    ASSERT_STREQ(""{ }"", message_mre.get().c_str());

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_FALSE(log_entries.empty());

    ASSERT_TRUE(has_log_entry(""[debug    ] processing message: { }\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_send, message_sent)
{
    std::string actual_message;

    auto websocket_client = create_test_websocket_client(
        /* send function */ [&actual_message](const std::string& message, std::function<void(std::exception_ptr)> callback)
        {
            actual_message = message;
            callback(nullptr);
        });

    auto connection = create_connection(websocket_client);

    const std::string message{ ""Test message"" };

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->send(message, transfer_format::text, [&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_EQ(message, actual_message);
}

TEST(connection_impl_send, send_throws_if_connection_not_connected)
{
    auto connection =
        connection_impl::create(create_uri(), trace_level::none, std::make_shared<memory_log_writer>());

    auto mre = manual_reset_event<void>();
    connection->send(""whatever"", transfer_format::text, [&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception expected but not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(""cannot send data when the connection is not in the connected state. current connection state: disconnected"", e.what());
    }
}

TEST(connection_impl_send, exceptions_from_send_logged_and_propagated)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            callback(std::make_exception_ptr(std::runtime_error(""error"")));
        });

    auto connection = create_connection(websocket_client, writer, trace_level::error);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->send(""Test message"", transfer_format::text, [&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();

        ASSERT_TRUE(false); // exception expected but not thrown
    }
    catch (const std::runtime_error & e)
    {
        ASSERT_STREQ(""error"", e.what());
    }

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_FALSE(log_entries.empty());

    ASSERT_TRUE(has_log_entry(""[error    ] error sending data: error\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_set_message_received, callback_invoked_when_message_received)
{
    auto websocket_client = create_test_websocket_client();

    auto connection = create_connection(websocket_client);

    auto message = std::make_shared<std::string>();

    auto message_received_event = std::make_shared<cancellation_token>();
    connection->set_message_received([message, message_received_event](const std::string& m)
        {
            if (m == ""Test"")
            {
                *message = m;
            }

            if (m == ""release"")
            {
                message_received_event->cancel();
            }
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    websocket_client->receive_message(""Test"");
    websocket_client->receive_message(""release"");

    ASSERT_FALSE(message_received_event->wait(5000));

    ASSERT_EQ(""Test"", *message);
}

TEST(connection_impl_set_message_received, exception_from_callback_caught_and_logged)
{
    auto websocket_client = create_test_websocket_client();

    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    auto connection = create_connection(websocket_client, writer, trace_level::error);

    auto message_received_event = std::make_shared<cancellation_token>();
    connection->set_message_received([message_received_event](const std::string& m)
        {
            if (m == ""throw"")
            {
                throw std::runtime_error(""oops"");
            }

            if (m == ""release"")
            {
                message_received_event->cancel();
            }
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    websocket_client->receive_message(""throw"");
    websocket_client->receive_message(""release"");

    ASSERT_FALSE(message_received_event->wait(5000));

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_FALSE(log_entries.empty());

    ASSERT_TRUE(has_log_entry(""[error    ] message_received callback threw an exception: oops\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_set_message_received, non_std_exception_from_callback_caught_and_logged)
{
    auto websocket_client = create_test_websocket_client();

    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    auto connection = create_connection(websocket_client, writer, trace_level::error);

    auto message_received_event = std::make_shared<cancellation_token>();
    connection->set_message_received([message_received_event](const std::string& m)
        {
            if (m == ""throw"")
            {
                throw 42;
            }

            if (m == ""release"")
            {
                message_received_event->cancel();
            }
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    websocket_client->receive_message(""throw"");
    websocket_client->receive_message(""release"");

    ASSERT_FALSE(message_received_event->wait(5000));

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_FALSE(log_entries.empty());

    ASSERT_TRUE(has_log_entry(""[error    ] message_received callback threw an unknown exception\\n"", log_entries)) << dump_vector(log_entries);
}

void can_be_set_only_in_disconnected_state(std::function<void(connection_impl*)> callback, const char* expected_exception_message)
{
    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    try
    {
        callback(connection.get());
        ASSERT_TRUE(false); // exception expected but not thrown
    }
    catch (const signalr_exception & e)
    {
        ASSERT_STREQ(expected_exception_message, e.what());
    }
}

TEST(connection_impl_set_configuration, set_message_received_callback_can_be_set_only_in_disconnected_state)
{
    can_be_set_only_in_disconnected_state(
        [](connection_impl* connection) { connection->set_message_received([](const std::string&) {}); },
        ""cannot set the callback when the connection is not in the disconnected state. current connection state: connected"");
}

TEST(connection_impl_set_configuration, set_disconnected_callback_can_be_set_only_in_disconnected_state)
{
    can_be_set_only_in_disconnected_state(
        [](connection_impl* connection) { connection->set_disconnected([](std::exception_ptr) {}); },
        ""cannot set the disconnected callback when the connection is not in the disconnected state. current connection state: connected"");
}

TEST(connection_impl_stop, stopping_disconnected_connection_is_no_op)
{
    std::shared_ptr<log_writer> writer{ std::make_shared<memory_log_writer>() };
    auto connection = connection_impl::create(create_uri(), trace_level::verbose, writer);
    auto mre = manual_reset_event<void>();
    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    ASSERT_EQ(connection_state::disconnected, connection->get_connection_state());

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_EQ(2U, log_entries.size()) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[info     ] stopping connection\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[info     ] acquired lock in shutdown()\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_stop, stopping_disconnecting_connection_returns_canceled_task)
{
    cancellation_token close_event;
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked""))); },
        /* connect function */ [&close_event](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(nullptr); },
        /* close function */ [&close_event](std::function<void(std::exception_ptr)> callback)
        {
            close_event.wait();
            callback(nullptr);
        });

    auto connection = create_connection(websocket_client, writer, trace_level::verbose);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    try
    {
        auto mre_stop = manual_reset_event<void>();
        connection->stop([&mre_stop](std::exception_ptr exception)
            {
                mre_stop.set(exception);
            }, nullptr);

        mre_stop.get();
        ASSERT_FALSE(true); // exception expected but not thrown
    }
    catch (const signalr::canceled_exception&)
    {
    }

    close_event.cancel();
    mre.get();

    ASSERT_EQ(connection_state::disconnected, connection->get_connection_state());

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connecting -> connected\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connected -> disconnecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnecting -> disconnected\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_stop, can_start_and_stop_connection)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::verbose);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connecting -> connected\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connected -> disconnecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnecting -> disconnected\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_stop, can_start_and_stop_connection_multiple_times)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    {
        auto websocket_client = create_test_websocket_client();
        auto connection = create_connection(websocket_client, writer, trace_level::verbose);

        auto mre = manual_reset_event<void>();
        connection->start([&mre](std::exception_ptr exception)
            {
                mre.set(exception);
            });

        mre.get();

        connection->stop([&mre](std::exception_ptr exception)
            {
                mre.set(exception);
            }, nullptr);

        mre.get();

        connection->start([&mre](std::exception_ptr exception)
            {
                mre.set(exception);
            });

        mre.get();
    }

    auto memory_writer = std::dynamic_pointer_cast<memory_log_writer>(writer);

    // The connection_impl will be destroyed when the last reference to shared_ptr holding is released. This can happen
    // on a different thread in which case the dtor will be invoked on a different thread so we need to wait for this
    // to happen and if it does not the test will fail
    for (int wait_time_ms = 5; wait_time_ms < 100 && memory_writer->get_log_entries().size() < 16; wait_time_ms <<= 1)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(wait_time_ms));
    }

    auto log_entries = memory_writer->get_log_entries();
    ASSERT_EQ(16U, log_entries.size()) << dump_vector(log_entries);

    auto second_half = std::vector<std::string>(log_entries.begin() + 8, log_entries.end());

    log_entries = std::vector<std::string>(log_entries.begin(), log_entries.begin() + 8);

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connecting -> connected\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connected -> disconnecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnecting -> disconnected\\n"", log_entries)) << dump_vector(log_entries);

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", second_half)) << dump_vector(second_half);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connecting -> connected\\n"", second_half)) << dump_vector(second_half);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connected -> disconnecting\\n"", second_half)) << dump_vector(second_half);
    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnecting -> disconnected\\n"", second_half)) << dump_vector(second_half);
}

TEST(connection_impl_stop, dtor_stops_the_connection)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    {
        auto websocket_client = create_test_websocket_client();
        auto connection = create_connection(websocket_client, writer, trace_level::verbose);

        auto mre = manual_reset_event<void>();
        connection->start([&mre](std::exception_ptr exception)
            {
                mre.set(exception);
            });

        mre.get();
    }

    auto memory_writer = std::dynamic_pointer_cast<memory_log_writer>(writer);

    // The connection_impl will be destroyed when the last reference to shared_ptr holding is released. This can happen
    // on a different thread in which case the dtor will be invoked on a different thread so we need to wait for this
    // to happen and if it does not the test will fail
    for (int wait_time_ms = 5; wait_time_ms < 6000 && memory_writer->get_log_entries().size() < 7; wait_time_ms <<= 1)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(wait_time_ms));
    }

    auto log_entries = memory_writer->get_log_entries();

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connecting -> connected\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connected -> disconnecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnecting -> disconnected\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_stop, stop_cancels_ongoing_start_request)
{
    auto disconnect_completed_event = std::make_shared<cancellation_token>();

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{ \\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }""
                : """";

            return http_response{ 200, response_body };
        }));

    auto wait_for_start_mre = manual_reset_event<void>();

    auto websocket_client = create_test_websocket_client(
        [](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::exception())); },
        [disconnect_completed_event, &wait_for_start_mre](const std::string&, std::function<void(std::exception_ptr)> callback) {
            wait_for_start_mre.set();
            disconnect_completed_event->wait();
            callback(nullptr);
        });

    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };
    auto connection = connection_impl::create(create_uri(), trace_level::verbose, writer,
        [http_client](const signalr_client_config& config) {
            http_client->set_scheduler(config.get_scheduler());
            return http_client;
        }, [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    wait_for_start_mre.get();

    connection->stop([disconnect_completed_event](std::exception_ptr)
        {
            disconnect_completed_event->cancel();
        }, nullptr);

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception expected but not thrown
    }
    catch (const canceled_exception&)
    {
    }

    ASSERT_EQ(connection_state::disconnected, connection->get_connection_state());

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[info     ] [websocket transport] connecting to: ws://stop_cancels_ongoing_start_request/?id=f7707523-307d-4cba-9abf-3eef701241e8\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[info     ] stopping connection\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[info     ] acquired lock in shutdown()\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[info     ] starting the connection has been canceled.\\n"", log_entries)) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[verbose  ] connecting -> disconnected\\n"", log_entries)) << dump_vector(log_entries);
}

// Test races with start and stop
TEST(connection_impl_stop, DISABLED_ongoing_start_request_canceled_if_connection_stopped_before_init_message_received)
{
    auto stop_mre = manual_reset_event<void>();
    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([&stop_mre](const std::string& url, http_request)
        {
            stop_mre.get();

            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{ \\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }""
                : """";

            return http_response{ 200, response_body };
        }));

    auto websocket_client = create_test_websocket_client();

    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };
    auto connection = connection_impl::create(create_uri(), trace_level::verbose, writer,
        [http_client](const signalr_client_config& config) {
            http_client->set_scheduler(config.get_scheduler());
            return http_client;
        }, [websocket_client](const signalr_client_config& config)
        {
            websocket_client->set_config(config);
            return websocket_client;
        });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    connection->stop([&stop_mre](std::exception_ptr exception)
        {
            stop_mre.set(exception);
        }, nullptr);

    try
    {
        mre.get();
        ASSERT_TRUE(false); // exception expected but not thrown
    }
    catch (const std::exception&)
    {
    }

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_EQ(5U, log_entries.size()) << dump_vector(log_entries);
    ASSERT_EQ(""[state change] disconnected -> connecting\\n"", remove_date_from_log_entry(log_entries[0]));
    ASSERT_EQ(""[info        ] stopping connection\\n"", remove_date_from_log_entry(log_entries[1]));
    ASSERT_EQ(""[info        ] acquired lock in shutdown()\\n"", remove_date_from_log_entry(log_entries[2]));
    ASSERT_EQ(""[info        ] starting the connection has been canceled.\\n"", remove_date_from_log_entry(log_entries[3]));
    ASSERT_EQ(""[state change] connecting -> disconnected\\n"", remove_date_from_log_entry(log_entries[4]));
}

TEST(connection_impl_stop, stop_invokes_disconnected_callback)
{
    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client);

    auto disconnected_invoked = false;
    connection->set_disconnected([&disconnected_invoked](std::exception_ptr) { disconnected_invoked = true; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    ASSERT_TRUE(disconnected_invoked);
}

TEST(connection_impl_stop, std_exception_from_disconnected_callback_caught_and_logged)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::error);

    connection->set_disconnected([](std::exception_ptr) { throw std::runtime_error(""exception from disconnected""); });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_EQ(1U, log_entries.size()) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[error    ] disconnected callback threw an exception: exception from disconnected\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_stop, exception_from_disconnected_callback_caught_and_logged)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::error);

    connection->set_disconnected([](std::exception_ptr) { throw 42; });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_EQ(1U, log_entries.size()) << dump_vector(log_entries);
    ASSERT_TRUE(has_log_entry(""[error    ] disconnected callback threw an unknown exception\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_impl_stop, transport_error_invokes_disconnected_callback)
{
    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client);

    auto disconnect_mre = manual_reset_event<void>();
    connection->set_disconnected([&disconnect_mre](std::exception_ptr ex) { disconnect_mre.set(ex); });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    ASSERT_FALSE(websocket_client->receive_loop_started.wait(1000));
    websocket_client->receive_message(std::make_exception_ptr(custom_exception(""error"")));

    try
    {
        disconnect_mre.get();
        ASSERT_TRUE(false);
    }
    catch (const custom_exception& ex)
    {
        ASSERT_STREQ(""error"", ex.what());
    }

    ASSERT_EQ(connection_state::disconnected, connection->get_connection_state());
}

TEST(connection_impl_config, custom_headers_set_in_requests)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([](const std::string& url, http_request)
        {
            auto response_body =
                url.find(""/negotiate"") != std::string::npos
                ? ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }""
                : """";

            /*auto request = new web_request_stub((unsigned short)200, ""OK"", response_body);
            request->on_get_response = [](web_request_stub& request)
            {
                auto http_headers = request.m_signalr_client_config.get_http_headers();
                ASSERT_EQ(1U, http_headers.size());
                ASSERT_EQ(_XPLATSTR(""42""), http_headers[_XPLATSTR(""Answer"")]);
            };*/

            return http_response{ 200, response_body };
        }));

    auto websocket_client = create_test_websocket_client();

    auto connection =
        connection_impl::create(create_uri(), trace_level::verbose,
            writer, [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            });

    signalr::signalr_client_config signalr_client_config{};
    auto http_headers = signalr_client_config.get_http_headers();
    http_headers[""Answer""] = ""42"";
    signalr_client_config.set_http_headers(http_headers);
    connection->set_client_config(signalr_client_config);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    ASSERT_EQ(connection_state::disconnected, connection->get_connection_state());
}

TEST(connection_impl_set_config, config_can_be_set_only_in_disconnected_state)
{
    can_be_set_only_in_disconnected_state(
        [](connection_impl* connection)
        {
            signalr::signalr_client_config signalr_client_config;
            connection->set_client_config(signalr_client_config);
        }, ""cannot set client config when the connection is not in the disconnected state. current connection state: connected"");
}

TEST(connection_impl_change_state, change_state_logs)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::verbose);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });
    mre.get();

    auto log_entries = std::dynamic_pointer_cast<memory_log_writer>(writer)->get_log_entries();
    ASSERT_FALSE(log_entries.empty());

    ASSERT_TRUE(has_log_entry(""[verbose  ] disconnected -> connecting\\n"", log_entries)) << dump_vector(log_entries);
}

TEST(connection_id, connection_id_is_set_if_start_fails_but_negotiate_request_succeeds)
{
    std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());

    auto websocket_client = create_test_websocket_client(
        /* send function */ [](const std::string, std::function<void(std::exception_ptr)> callback) { callback(std::make_exception_ptr(std::runtime_error(""should not be invoked"")));  },
        /* connect function */[](const std::string&, std::function<void(std::exception_ptr)> callback)
        {
            callback(std::make_exception_ptr(std::runtime_error(""connecting failed"")));
        });

    auto connection = create_connection(websocket_client, writer, trace_level::error);

    ASSERT_EQ("""", connection->get_connection_id());

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    try
    {
        mre.get();
        ASSERT_TRUE(false);
    }
    catch (const std::runtime_error & ex)
    {
        ASSERT_STREQ(""connecting failed"", ex.what());
    }

    ASSERT_EQ(""f7707523-307d-4cba-9abf-3eef701241e8"", connection->get_connection_id());
}

TEST(connection_id, can_get_connection_id_when_connection_in_connected_state)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::verbose);

    std::string connection_id;
    auto mre = manual_reset_event<void>();
    connection->start([&mre, &connection_id, connection](std::exception_ptr exception)
        {
            connection_id = connection->get_connection_id();
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    ASSERT_EQ(""f7707523-307d-4cba-9abf-3eef701241e8"", connection_id);
}

TEST(connection_id, can_get_connection_id_after_connection_has_stopped)
{
    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client();
    auto connection = create_connection(websocket_client, writer, trace_level::verbose);

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    ASSERT_EQ(""f7707523-307d-4cba-9abf-3eef701241e8"", connection->get_connection_id());
}

TEST(connection_id, connection_id_reset_when_starting_connection)
{
    auto fail_http_requests = false;

    auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };

    auto websocket_client = create_test_websocket_client();

    auto http_client = std::shared_ptr<test_http_client>(new test_http_client([&fail_http_requests](const std::string& url, http_request)
        {
            if (!fail_http_requests) {
                auto response_body =
                    url.find(""/negotiate"") != std::string::npos
                    ? ""{\\""connectionId\\"" : \\""f7707523-307d-4cba-9abf-3eef701241e8\\"", ""
                    ""\\""availableTransports\\"" : [ { \\""transport\\"": \\""WebSockets\\"", \\""transferFormats\\"": [ \\""Text\\"", \\""Binary\\"" ] } ] }""
                    : """";

                return http_response{ 200, response_body };
            }

            return http_response{ 500, """" };
        }));

    auto connection =
        connection_impl::create(create_uri(), trace_level::none, std::make_shared<memory_log_writer>(),
            [http_client](const signalr_client_config& config) {
                http_client->set_scheduler(config.get_scheduler());
                return http_client;
            }, [websocket_client](const signalr_client_config& config)
            {
                websocket_client->set_config(config);
                return websocket_client;
            });

    auto mre = manual_reset_event<void>();
    connection->start([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        });

    mre.get();

    connection->stop([&mre](std::exception_ptr exception)
        {
            mre.set(exception);
        }, nullptr);

    mre.get();

    ASSERT_EQ(""f7707523-307d-4cba-9abf-3eef701241e8"", connection->get_connection_id());

    fail_http_requests = true;

    connection->start([&mre](std::exception_ptr)
        {
            mre.set();
        });

    mre.get();

    ASSERT_EQ("""", connection->get_connection_id());
}
",16179,True,3944.572517148161,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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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>>.


[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== 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]]
[float]
=== Regressions

Infra/Core::
* Restore date aggregation performance in UTC case {es-pull}38221[#38221] (issue: {es-issue}37826[#37826])



[[upgrade-7.3.0]]
[float]
=== 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]


",12375,True,3131.062147566494,median
"[[scoreCalculation]]
= Score calculation
:doctype: book
:sectnums:
:icons: font


[[scoreTerminology]]
== Score terminology


[[whatIsAScore]]
=== What is a score?

Every `@PlanningSolution` class has a score.
The score is an objective way to compare two solutions.
The solution with the higher score is better.
The `Solver` aims to find the solution with the highest `Score` of all possible solutions.
The _best solution_ is the solution with the highest `Score` that `Solver` has encountered during solving,
which might be the __optimal solution__.

OptaPlanner cannot automatically know which solution is best for your business,
so you need to tell it how to calculate the score of a given `@PlanningSolution` instance according to your business needs.
If you forget or are unable to implement an important business constraint, the solution is probably useless:

image::score-calculation/optimalWithIncompleteConstraints.png[align=""center""]


[[formalizeTheBusinessConstraints]]
=== Formalize the business constraints

To implement a verbal business constraint, it needs to be formalized as a score constraint.
Luckily, defining constraints in OptaPlanner is very flexible through the following score techniques:

* **Score signum (positive or negative)**: maximize or minimize a constraint type
* **Score weight**: put a cost/profit on a constraint type
* **Score level (hard, soft, ...)**: prioritize a group of constraint types
* *Pareto scoring* (rarely used)

Take the time to acquaint yourself with the first three techniques.
Once you understand them, formalizing most business constraints becomes straightforward.

[NOTE]
====
Do not presume that your business knows all its score constraints in advance.
Expect score constraints to be added, changed or removed after the first releases.
====


[[scoreConstraintSignum]]
=== Score constraint signum (positive or negative)

All score techniques are based on constraints.
A constraint can be a simple pattern (such as __Maximize the apple harvest in the solution__) or a more complex pattern.
A positive constraint is a constraint you want to maximize.
A negative constraint is a constraint you want to minimize

image::score-calculation/positiveAndNegativeConstraints.png[align=""center""]

The image above illustrates that **the optimal solution always has the highest score**,
regardless if the constraints are positive or negative.

Most planning problems have only negative constraints and therefore have a negative score.
In that case, the score is the sum of the weight of the negative constraints being broken, with a perfect score of 0.
For example in n queens, the score is the negative of the number of queen pairs which can attack each other.

Negative and positive constraints can be combined, even in the same score level.

When a constraint activates (because the negative constraint is broken or the positive constraint is fulfilled)
on a certain planning entity set, it is called a __constraint match__.


[[scoreConstraintWeight]]
=== Score constraint weight

Not all score constraints are equally important.
If breaking one constraint is equally bad as breaking another constraint x times,
then those two constraints have a different weight (but they are in the same score level).
For example in vehicle routing, you can make one _unhappy driver_ constraint match count
as much as two _fuel tank usage_ constraint matches:

image::score-calculation/scoreWeighting.png[align=""center""]

Score weighting is easy in use cases where you can __put a price tag on everything__.
In that case, the positive constraints maximize revenue and the negative constraints minimize expenses, so together they maximize profit.
Alternatively, score weighting is also often used to create social <<fairnessScoreConstraints,fairness>>.
For example, a nurse, who requests a free day, pays a higher weight on New Years eve than on a normal day.

The weight of a constraint match can depend on the planning entities involved.
For example in cloud balancing, the weight of the soft constraint match for an active `Computer`
is the maintenance `cost` of that `Computer` (which differs per computer).

Putting a good weight on a constraint is often a difficult analytical decision,
because it is about making choices and trade-offs against other constraints.
Different stakeholders have different priorities.
*Don't waste time with constraint weight discussions at the start of an implementation,
instead add a <<constraintConfiguration, constraint configuration>>
and  allow users to change them through a UI.*
A non-accurate weight is less damaging than mediocre algorithms:

image::score-calculation/scoreTradeoffInPerspective.png[align=""center""]

Most use cases use a `Score` with `int` weights, such as <<hardSoftScore,HardSoftScore>>.


[[scoreLevel]]
=== Score constraint level (hard, soft, ...)

Sometimes a score constraint outranks another score constraint, no matter how many times the latter is broken.
In that case, those score constraints are in different levels.
For example, a nurse cannot do two shifts at the same time (due to the constraints of physical reality),
so this outranks all nurse happiness constraints.

Most use cases have only two score levels, hard and soft.
The levels of two scores are compared lexicographically.
The first score level gets compared first.
If those differ, the remaining score levels are ignored.
For example, a score that breaks `0` hard constraints and `1000000` soft constraints is better
than a score that breaks `1` hard constraint and `0` soft constraints.

image::score-calculation/scoreLevels.png[align=""center""]

If there are two (or more) score levels, for example <<hardSoftScore,HardSoftScore>>,
then a score is _feasible_ if no hard constraints are broken.

[NOTE]
====
By default, OptaPlanner will always assign all planning variables a planning value.
If there is no feasible solution, this means the best solution will be infeasible.
To instead leave some of the planning entities unassigned, apply xref:repeated-planning/repeated-planning.adoc#overconstrainedPlanning[overconstrained planning].
====

For each constraint, you need to pick a score level, a score weight and a score signum.
For example: `-1soft` which has score level of ``soft``, a weight of `1` and a negative signum.
Do not use a big constraint weight when your business actually wants different score levels.
That hack, known as __score folding__, is broken:

image::score-calculation/scoreFoldingIsBroken.png[align=""center""]


[NOTE]
====
Your business might tell you that your hard constraints all have the same weight, because they cannot be broken (so the weight does not matter). This is not true because if no feasible solution exists for a specific dataset, the least infeasible solution allows the business to estimate how many business resources they are lacking.
For example in cloud balancing, how many new computers to buy.

Furthermore, it will likely create a <<scoreTrap,score trap>>.
For example in cloud balance if a `Computer` has seven CPU too little for its ``Process``es, then it must be weighted seven times as much as if it had only one CPU too little.
====

Three or more score levels are also supported.
For example: a company might decide that profit outranks employee satisfaction (or vice versa),
while both are outranked by the constraints of physical reality.

[NOTE]
====
To model <<fairnessScoreConstraints,fairness or load balancing>>, there is no need to use lots of score levels
(even though OptaPlanner can handle many score levels).
====

Most use cases use a `Score` with two or three weights,
such as <<hardSoftScore,HardSoftScore>> and <<hardMediumSoftScore,HardMediumSoftScore>>.


[[paretoScoring]]
=== Pareto scoring (AKA multi-objective optimization scoring)

Far less common is the use case of pareto optimization, which is also known as _multi-objective optimization_.
In pareto scoring, score constraints are in the same score level, yet they are not weighted against each other.
When two scores are compared, each of the score constraints are compared individually and the score with the most dominating score constraints wins.
Pareto scoring can even be combined with score levels and score constraint weighting.

Consider this example with positive constraints, where we want to get the most apples and oranges.
Since it is impossible to compare apples and oranges, we cannot weigh them against each other.
Yet, despite that we cannot compare them, we can state that two apples are better than one apple.
Similarly, we can state that two apples and one orange are better than just one orange.
So despite our inability to compare some Scores conclusively (at which point we declare them equal), we can find a set of optimal scores.
Those are called pareto optimal.

image::score-calculation/paretoOptimizationScoring.png[align=""center""]

Scores are considered equal far more often.
It is left up to a human to choose the better out of a set of best solutions (with equal scores) found by OptaPlanner.
In the example above, the user must choose between solution A (three apples and one orange) and solution B (one apple and six oranges). It is guaranteed that OptaPlanner has not found another solution which has more apples or more oranges or even a better combination of both (such as two apples and three oranges).

Pareto scoring is currently not supported in OptaPlanner.

[NOTE]
====
A pareto ``Score``'s `compareTo` method is not transitive because it does a pareto comparison.
For example: having two apples is greater than one apple.
One apple is equal to One orange.
Yet, two apples are not greater than one orange (but actually equal). Pareto comparison violates the contract of the interface ``java.lang.Comparable``'s `compareTo` method, but Planners systems are __pareto comparison safe__, unless explicitly stated otherwise in this documentation.
====


[[combiningScoreTechniques]]
=== Combining score techniques

All the score techniques mentioned above, can be combined seamlessly:

image::score-calculation/scoreComposition.png[align=""center""]


[[scoreInterface]]
=== `Score` interface

A score is represented by the `Score` interface, which naturally extends ``Comparable``:

[source,java,options=""nowrap""]
----
public interface Score<...> extends Comparable<...> {
    ...
}
----

The `Score` implementation to use depends on your use case.
Your score might not efficiently fit in a single `long` value.
OptaPlanner has several built-in `Score` implementations, but you can implement a custom `Score` too.
Most use cases tend to use the built-in ``HardSoftScore``.

image::score-calculation/scoreClassDiagram.png[align=""center""]

All Score implementations also have an `initScore` (which is an ``int``).It is mostly intended for internal use in OptaPlanner: it is the negative number of uninitialized planning variables.
From a user's perspective this is ``0``, unless a Construction Heuristic is terminated before it could initialize all planning variables (in which case `Score.isSolutionInitialized()` returns ``false``).

The `Score` implementation (for example ``HardSoftScore``) must be the same throughout a `Solver` runtime.
The `Score` implementation is configured in the solution domain class:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class CloudBalance {
    ...

    @PlanningScore
    private HardSoftScore score;

}
----

[[avoidFloatingPointNumbersInScoreCalculation]]
=== Avoid floating point numbers in score calculation

Avoid the use of `float` or `double` in score calculation.
Use `BigDecimal` or scaled `long` instead.

Floating point numbers (``float`` and ``double``) cannot represent a decimal number correctly.
For example: a `double` cannot hold the value `0.05` correctly.
Instead, it holds the nearest representable value.
Arithmetic (including addition and subtraction) with floating point numbers, especially for planning problems, leads to incorrect decisions:

image::score-calculation/scoreWeightType.png[align=""center""]

Additionally, floating point number addition is not associative:

[source,java,options=""nowrap""]
----
System.out.println( ((0.01 + 0.02) + 0.03) == (0.01 + (0.02 + 0.03)) ); // returns false
----

This leads to __score corruption__.

Decimal numbers (``BigDecimal``) have none of these problems.

[NOTE]
====
BigDecimal arithmetic is considerably slower than ``int``, `long` or `double` arithmetic.
In experiments we have seen the score calculation take five times longer.

Therefore, in many cases, it can be worthwhile to multiply _all_ numbers for a single score weight by a plural of ten, so the score weight fits in a scaled `int` or ``long``.
For example, if we multiply all weights by ``1000``, a fuelCost of `0.07` becomes a fuelCostMillis of `70` and no longer uses a decimal score weight.
====


[[scoreType]]
== Choose a score type

Depending on the number of score levels and type of score weights you need, choose a `Score` type.
Most use cases use a ``HardSoftScore``.

[NOTE]
====
To properly write a `Score` to a database (with JPA/Hibernate) or to XML/JSON (with XStream/JAXB/Jackson),
see xref:integration/integration.adoc#integration[the integration chapter].
====


[[simpleScore]]
=== `SimpleScore`

A `SimpleScore` has a single `int` value, for example ``-123``.
It has a single score level.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private SimpleScore score;
----

Variants of this `Score` type:

* `SimpleLongScore` uses a `long` value instead of an `int` value.
* `SimpleBigDecimalScore` uses a `BigDecimal` value instead of an `int` value.


[[hardSoftScore]]
=== `HardSoftScore` (Recommended)

A `HardSoftScore` has a hard `int` value and a soft `int` value, for example ``-123hard/-456soft``.
It has two score levels (hard and soft).

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardSoftScore score;
----

Variants of this `Score` type:

* `HardSoftLongScore` uses `long` values instead of `int` values.
* `HardSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[hardMediumSoftScore]]
=== `HardMediumSoftScore`

A `HardMediumSoftScore` which has a hard `int` value, a medium `int` value and a soft `int` value, for example ``-123hard/-456medium/-789soft``.
It has three score levels (hard, medium and soft).
The hard level determines if the solution is feasible,
and the medium level and soft level score values determine
how well the solution meets business goals.
Higher medium values take precedence over soft values irrespective of the soft value.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardMediumSoftScore score;
----

Variants of this `Score` type:

* `HardMediumSoftLongScore` uses `long` values instead of `int` values.
* `HardMediumSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[bendableScore]]
=== `BendableScore`

A `BendableScore` has a configurable number of score levels.
It has an array of hard `int` values and an array of soft `int` values,
for example with two hard levels and three soft levels, the score can be ``[-123/-456]hard/[-789/-012/-345]soft``.
In that case, it has five score levels.
A solution is feasible if all hard levels are at least zero.

A BendableScore with one hard level and one soft level is equivalent to a HardSoftScore,
while a BendableScore with one hard level and two soft levels is equivalent to a HardMediumSoftScore.

[source,java,options=""nowrap""]
----
    @PlanningScore(bendableHardLevelsSize = 2, bendableSoftLevelsSize = 3)
    private BendableScore score;
----

The number of hard and soft score levels need to be set at compilation time.
It is not flexible to change during solving.

[NOTE]
====
Do not use a `BendableScore` with seven levels just because you have seven constraints.
It is extremely rare to use a different score level for each constraint, because that means one constraint match on soft 0 outweighs even a million constraint matches of soft 1.

Usually, multiple constraints share the same level and are weighted against each other.
Use <<explainingTheScore,explaining the score>> to get the weight of individual constraints in the same level.
====

Variants of this `Score` type:

* `BendableLongScore` uses `long` values instead of `int` values.
* `BendableBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[calculateTheScore]]
== Calculate the `Score`


[[scoreCalculationTypes]]
=== Score calculation types

There are several ways to calculate the `Score` of a solution:

* **<<easyJavaScoreCalculation,Easy Java score calculation>>**: Implement all constraints together in a single method in Java (or another JVM language). Does not scale.
* **xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams score calculation]**: Implement each constraint as a separate Constraint Stream in Java (or another JVM language). Fast and scalable.
* **<<incrementalJavaScoreCalculation,Incremental Java score calculation>>** (not recommended): Implement multiple low-level methods in Java (or another JVM language). Fast and scalable. Very difficult to implement and maintain.
* **xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation]**: Implement each constraint as a separate score rule in DRL. Scalable.

Every score calculation type can work with any Score definition (such as ``HardSoftScore`` or ``HardMediumSoftScore``).
All score calculation types are Object Oriented and can reuse existing Java code.

[IMPORTANT]
====
The score calculation must be read-only.
It must not change the planning entities or the problem facts in any way.
For example, it must not call a setter method on a planning entity in the score calculation.

OptaPlanner does not recalculate the score of a solution if it can predict it (unless an xref:planner-configuration/planner-configuration.adoc#environmentMode[environmentMode assertion] is enabled).
For example, after a winning step is done, there is no need to calculate the score because that move was done and undone earlier.
As a result, there is no guarantee that changes applied during score calculation actually happen.

To update planning entities when the planning variable change, use xref:shadow-variable/shadow-variable.adoc#shadowVariable[shadow variables] instead.
====


[[easyJavaScoreCalculation]]
=== Easy Java score calculation

An easy way to implement your score calculation in Java.

* Advantages:
** Plain old Java: no learning curve
** Opportunity to delegate score calculation to an existing code base or legacy system
* Disadvantages:
** Slower
** Does not scale because there is no <<incrementalScoreCalculation,incremental score calculation>>

Implement the one method of the interface ``EasyScoreCalculator``:

[source,java,options=""nowrap""]
----
public interface EasyScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    Score_ calculateScore(Solution_ solution);

}
----

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensEasyScoreCalculator
    implements EasyScoreCalculator<NQueens, SimpleScore> {

    @Override
    public SimpleScore calculateScore(NQueens nQueens) {
        int n = nQueens.getN();
        List<Queen> queenList = nQueens.getQueenList();

        int score = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                Queen leftQueen = queenList.get(i);
                Queen rightQueen = queenList.get(j);
                if (leftQueen.getRow() != null && rightQueen.getRow() != null) {
                    if (leftQueen.getRowIndex() == rightQueen.getRowIndex()) {
                        score--;
                    }
                    if (leftQueen.getAscendingDiagonalIndex() == rightQueen.getAscendingDiagonalIndex()) {
                        score--;
                    }
                    if (leftQueen.getDescendingDiagonalIndex() == rightQueen.getDescendingDiagonalIndex()) {
                        score--;
                    }
                }
            }
        }
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
  </scoreDirectorFactory>
----

To configure values of an `EasyScoreCalculator` dynamically in the solver configuration
(so the xref:benchmarking-and-tweaking/benchmarking-and-tweaking.adoc#benchmarker[Benchmarker] can tweak those parameters),
add the `easyScoreCalculatorCustomProperties` element and use xref:planner-configuration/planner-configuration.adoc#customPropertiesConfiguration[custom properties]:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>...MyEasyScoreCalculator</easyScoreCalculatorClass>
    <easyScoreCalculatorCustomProperties>
      <property name=""myCacheSize"" value=""1000"" />
    </easyScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[incrementalJavaScoreCalculation]]
=== Incremental Java score calculation

A way to implement your score calculation incrementally in Java.

* Advantages:
** Very fast and scalable
*** Currently the fastest if implemented correctly
* Disadvantages:
** Hard to write
*** A scalable implementation heavily uses maps, indexes, ... (things the Drools rule engine can do for you)
*** You have to learn, design, write and improve all these performance optimizations yourself
** Hard to read
*** Regular score constraint changes can lead to a high maintenance cost

Implement all the methods of the interface `IncrementalScoreCalculator`:

[source,java,options=""nowrap""]
----
public interface IncrementalScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    void resetWorkingSolution(Solution_ workingSolution);

    void beforeEntityAdded(Object entity);

    void afterEntityAdded(Object entity);

    void beforeVariableChanged(Object entity, String variableName);

    void afterVariableChanged(Object entity, String variableName);

    void beforeEntityRemoved(Object entity);

    void afterEntityRemoved(Object entity);

    Score_ calculateScore();

}
----

image::score-calculation/incrementalScoreCalculatorSequenceDiagram.png[align=""center""]

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensAdvancedIncrementalScoreCalculator
    implements IncrementalScoreCalculator<NQueens, SimpleScore> {

    private Map<Integer, List<Queen>> rowIndexMap;
    private Map<Integer, List<Queen>> ascendingDiagonalIndexMap;
    private Map<Integer, List<Queen>> descendingDiagonalIndexMap;

    private int score;

    public void resetWorkingSolution(NQueens nQueens) {
        int n = nQueens.getN();
        rowIndexMap = new HashMap<Integer, List<Queen>>(n);
        ascendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        descendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        for (int i = 0; i < n; i++) {
            rowIndexMap.put(i, new ArrayList<Queen>(n));
            ascendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            descendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            if (i != 0) {
                ascendingDiagonalIndexMap.put(n - 1 + i, new ArrayList<Queen>(n));
                descendingDiagonalIndexMap.put((-i), new ArrayList<Queen>(n));
            }
        }
        score = 0;
        for (Queen queen : nQueens.getQueenList()) {
            insert(queen);
        }
    }

    public void beforeEntityAdded(Object entity) {
        // Do nothing
    }

    public void afterEntityAdded(Object entity) {
        insert((Queen) entity);
    }

    public void beforeVariableChanged(Object entity, String variableName) {
        retract((Queen) entity);
    }

    public void afterVariableChanged(Object entity, String variableName) {
        insert((Queen) entity);
    }

    public void beforeEntityRemoved(Object entity) {
        retract((Queen) entity);
    }

    public void afterEntityRemoved(Object entity) {
        // Do nothing
    }

    private void insert(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            int rowIndex = queen.getRowIndex();
            List<Queen> rowIndexList = rowIndexMap.get(rowIndex);
            score -= rowIndexList.size();
            rowIndexList.add(queen);
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            score -= ascendingDiagonalIndexList.size();
            ascendingDiagonalIndexList.add(queen);
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            score -= descendingDiagonalIndexList.size();
            descendingDiagonalIndexList.add(queen);
        }
    }

    private void retract(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            List<Queen> rowIndexList = rowIndexMap.get(queen.getRowIndex());
            rowIndexList.remove(queen);
            score += rowIndexList.size();
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            ascendingDiagonalIndexList.remove(queen);
            score += ascendingDiagonalIndexList.size();
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            descendingDiagonalIndexList.remove(queen);
            score += descendingDiagonalIndexList.size();
        }
    }

    public SimpleScore calculateScore() {
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensAdvancedIncrementalScoreCalculator</incrementalScoreCalculatorClass>
  </scoreDirectorFactory>
----

[IMPORTANT]
====
A piece of incremental score calculator code can be difficult to write and to review.
<<invalidScoreDetection,Assert its correctness>> by using an ``EasyScoreCalculator`` to fulfill
the assertions triggered by the ``environmentMode``.
====

To configure values of an `IncrementalScoreCalculator` dynamically in the solver configuration
(so the xref:benchmarking-and-tweaking/benchmarking-and-tweaking.adoc#benchmarker[Benchmarker] can tweak those parameters),
add the `incrementalScoreCalculatorCustomProperties` element and use xref:planner-configuration/planner-configuration.adoc#customPropertiesConfiguration[custom properties]:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>...MyIncrementalScoreCalculator</incrementalScoreCalculatorClass>
    <incrementalScoreCalculatorCustomProperties>
      <property name=""myCacheSize"" value=""1000""/>
    </incrementalScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[constraintMatchAwareIncrementalScoreCalculator]]
==== `ConstraintMatchAwareIncrementalScoreCalculator`

Optionally, also implement the `ConstraintMatchAwareIncrementalScoreCalculator` interface to:

* Explain a score by splitting it up per score constraint with `ScoreExplanation.getConstraintMatchTotalMap()`.
* Visualize or sort planning entities by how many constraints each one breaks with `ScoreExplanation.getIndictmentMap()`.
* Receive a detailed analysis if the `IncrementalScoreCalculator` is corrupted in `FAST_ASSERT` or `FULL_ASSERT` `environmentMode`,

[source,java,options=""nowrap""]
----
public interface ConstraintMatchAwareIncrementalScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    void resetWorkingSolution(Solution_ workingSolution, boolean constraintMatchEnabled);

    Collection<ConstraintMatchTotal<Score_>> getConstraintMatchTotals();

    Map<Object, Indictment<Score_>> getIndictmentMap();
}
----

For example in machine reassignment, create one `ConstraintMatchTotal` per constraint type and call `addConstraintMatch()` for each constraint match:

[source,java,options=""nowrap""]
----
public class MachineReassignmentIncrementalScoreCalculator
        implements ConstraintMatchAwareIncrementalScoreCalculator<MachineReassignment, HardSoftLongScore> {
    ...

    @Override
    public void resetWorkingSolution(MachineReassignment workingSolution, boolean constraintMatchEnabled) {
        resetWorkingSolution(workingSolution);
        // ignore constraintMatchEnabled, it is always presumed enabled
    }

    @Override
    public Collection<ConstraintMatchTotal<HardSoftLongScore>> getConstraintMatchTotals() {
        ConstraintMatchTotal<HardSoftLongScore> maximumCapacityMatchTotal = new DefaultConstraintMatchTotal<>(CONSTRAINT_PACKAGE,
            ""maximumCapacity"", HardSoftLongScore.ZERO);
        ...
        for (MrMachineScorePart machineScorePart : machineScorePartMap.values()) {
            for (MrMachineCapacityScorePart machineCapacityScorePart : machineScorePart.machineCapacityScorePartList) {
                if (machineCapacityScorePart.maximumAvailable < 0L) {
                    maximumCapacityMatchTotal.addConstraintMatch(
                            Arrays.asList(machineCapacityScorePart.machineCapacity),
                            HardSoftLongScore.valueOf(machineCapacityScorePart.maximumAvailable, 0));
                }
            }
        }
        ...
        List<ConstraintMatchTotal<HardSoftLongScore>> constraintMatchTotalList = new ArrayList<>(4);
        constraintMatchTotalList.add(maximumCapacityMatchTotal);
        ...
        return constraintMatchTotalList;
    }

    @Override
    public Map<Object, Indictment<HardSoftLongScore>> getIndictmentMap() {
        return null; // Calculate it non-incrementally from getConstraintMatchTotals()
    }
}
----

That `getConstraintMatchTotals()` code often duplicates some of the logic of the normal `IncrementalScoreCalculator` methods.
Constraint Streams and Drools Score Calculation don't have this disadvantage, because they are constraint match aware automatically when needed,
without any extra domain-specific code.


[[initializingScoreTrend]]
=== `InitializingScoreTrend`

The `InitializingScoreTrend` specifies how the Score will change as more and more variables are initialized (while the already initialized variables do not change). Some optimization algorithms (such Construction Heuristics and Exhaustive Search) run faster if they have such information.

For the Score (or each <<scoreLevel,score level>> separately), specify a trend:

* `ANY` (default): Initializing an extra variable can change the score positively or negatively. Gives no performance gain.
* `ONLY_UP` (rare): Initializing an extra variable can only change the score positively. Implies that:
** There are only positive constraints
** And initializing the next variable cannot unmatch a positive constraint that was matched by a previous initialized variable.
* ``ONLY_DOWN``: Initializing an extra variable can only change the score negatively. Implies that:
** There are only negative constraints
** And initializing the next variable cannot unmatch a negative constraint that was matched by a previous initialized variable.

Most use cases only have negative constraints.
Many of those have an `InitializingScoreTrend` that only goes down:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.cloudbalancing.score.CloudBalancingConstraintProvider</constraintProviderClass>
    <initializingScoreTrend>ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----

Alternatively, you can also specify the trend for each score level separately:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.cloudbalancing.score.CloudBalancingConstraintProvider</constraintProviderClass>
    <initializingScoreTrend>ONLY_DOWN/ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----


[[invalidScoreDetection]]
=== Invalid score detection

When you put the xref:planner-configuration/planner-configuration.adoc#environmentMode[`environmentMode`] in `FULL_ASSERT` (or ``FAST_ASSERT``),
it will detect score corruption in the <<incrementalScoreCalculation,incremental score calculation>>.
However, that will not verify that your score calculator actually implements your score constraints as your business desires.
For example, one constraint might consistently match the wrong pattern.
To verify the constraints against an independent implementation, configure a ``assertionScoreDirectorFactory``:

[source,xml,options=""nowrap""]
----
  <environmentMode>FAST_ASSERT</environmentMode>
  ...
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.nqueens.optional.score.NQueensConstraintProvider</constraintProviderClass>
    <assertionScoreDirectorFactory>
      <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
    </assertionScoreDirectorFactory>
  </scoreDirectorFactory>
----

This way, the `NQueensConstraintProvider` implementation is validated by the ``EasyScoreCalculator``.

[NOTE]
====
This works well to isolate score corruption,
but to verify that the constraint implement the real business needs,
xref:constraint-streams/constraint-streams.adoc#constraintStreamsTesting[a unit test with a ConstraintVerifier] is usually better.
====


[[scoreCalculationPerformanceTricks]]
== Score calculation performance tricks


[[scoreCalculationPerformanceTricksOverview]]
=== Overview

The `Solver` will normally spend most of its execution time running the score calculation
(which is called in its deepest loops).
Faster score calculation will return the same solution in less time with the same algorithm,
which normally means a better solution in equal time.


[[scoreCalculationSpeed]]
=== Score calculation speed

After solving a problem, the `Solver` will log the __score calculation speed per second__.
This is a good measurement of Score calculation performance,
despite that it is affected by non score calculation execution time.
It depends on the problem scale of the problem dataset.
Normally, even for high scale problems, it is higher than ``1000``, except if you are using an ``EasyScoreCalculator``.

[IMPORTANT]
====
When improving your score calculation, focus on maximizing the score calculation speed, instead of maximizing the best score.
A big improvement in score calculation can sometimes yield little or no best score improvement, for example when the algorithm is stuck in a local or global optima.
If you are watching the calculation speed instead, score calculation improvements are far more visible.

Furthermore, watching the calculation speed allows you to remove or add score constraints,
and still compare it with the original's calculation speed.
Comparing the best score with the original's best score is pointless: it's comparing apples and oranges.
====


[[incrementalScoreCalculation]]
=== Incremental score calculation (with deltas)

When a solution changes, incremental score calculation (AKA delta based score calculation)
calculates the delta with the previous state to find the new ``Score``,
instead of recalculating the entire score on every solution evaluation.

For example, when a single queen A moves from row `1` to ``2``,
it will not bother to check if queen B and C can attack each other, since neither of them changed:

image::score-calculation/incrementalScoreCalculationNQueens04.png[align=""center""]

Similarly in employee rostering:

image::score-calculation/incrementalScoreCalculationEmployeeRostering.png[align=""center""]

This is a huge performance and scalability gain.
*xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint Streams] or xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation] give you this huge scalability gain without forcing you to write a complicated incremental score calculation algorithm.*
Just let the rule engine do the hard work.

Notice that the speedup is relative to the size of your planning problem (your __n__), making incremental score calculation far more scalable.


[[avoidCallingRemoteServicesDuringScoreCalculation]]
=== Avoid calling remote services during score calculation

Do not call remote services in your score calculation (except if you are bridging `EasyScoreCalculator` to a legacy system). The network latency will kill your score calculation performance.
Cache the results of those remote services if possible.

If some parts of a constraint can be calculated once, when the `Solver` starts, and never change during solving,
then turn them into xref:planner-configuration/planner-configuration.adoc#cachedProblemFact[cached problem facts].


[[pointlessConstraints]]
=== Pointless constraints

If you know a certain constraint can never be broken (or it is always broken), do not write a score constraint for it.
For example in n queens, the score calculation does not check if multiple queens occupy the same column,
because a ``Queen``'s `column` never changes and every solution starts with each `Queen` on a different ``column``.

[NOTE]
====
Do not go overboard with this.
If some datasets do not use a specific constraint but others do, just return out of the constraint as soon as you can.
There is no need to dynamically change your score calculation based on the dataset.
====


[[buildInHardConstraint]]
=== Built-in hard constraint

Instead of implementing a hard constraint, it can sometimes be built in.
For example, if `Lecture` A should never be assigned to `Room` X, but it uses `ValueRangeProvider` on Solution,
so the `Solver` will often try to assign it to `Room` X too (only to find out that it breaks a hard constraint).
Use xref:planner-configuration/planner-configuration.adoc#valueRangeProviderOnPlanningEntity[a ValueRangeProvider on the planning entity] or xref:move-and-neighborhood-selection/move-and-neighborhood-selection.adoc#filteredSelection[filtered selection] to define that Course A should only be assigned a `Room` different than X.

This can give a good performance gain in some use cases, not just because the score calculation is faster,
but mainly because most optimization algorithms will spend less time evaluating infeasible solutions.
However, usually this is not a good idea because there is a real risk of trading short term benefits for long term harm:

* Many optimization algorithms rely on the freedom to break hard constraints when changing planning entities,
to get out of local optima.
* Both implementation approaches have limitations (feature compatibility, disabling automatic performance optimizations),
as explained in their documentation.


[[otherScoreCalculationPerformanceTricks]]
=== Other score calculation performance tricks

* Verify that your score calculation happens in the correct `Number` type.
If you are making the sum of `int` values, do not sum it in a `double` which takes longer.
* For optimal performance, always use server mode (``java -server``).
We have seen performance increases of 50% by turning on server mode.
* For optimal performance, use the latest Java version.
For example, in the past we have seen performance increases of 30% by switching from java 1.5 to 1.6.
* Always remember that premature optimization is the root of all evil.
Make sure your design is flexible enough to allow configuration based tweaking.


[[scoreTrap]]
=== Score trap

Make sure that none of your score constraints cause a score trap.
A trapped score constraint uses the same weight for different constraint matches, when it could just as easily use a different weight.
It effectively lumps its constraint matches together, which creates a flatlined score function for that constraint.
This can cause a solution state in which several moves need to be done to resolve or lower the weight of that single constraint.
Some examples of score traps:

* You need two doctors at each table, but you are only moving one doctor at a time. So the solver has no incentive to move a doctor to a table with no doctors. Punish a table with no doctors more than a table with only one doctor in that score constraint in the score function.
* Two exams need to be conducted at the same time, but you are only moving one exam at a time. So the solver has to move one of those exams to another timeslot without moving the other in the same move. Add a coarse-grained move that moves both exams at the same time.

For example, consider this score trap.
If the blue item moves from an overloaded computer to an empty computer, the hard score should improve.
The trapped score implementation fails to do that:

image::score-calculation/scoreTrap.png[align=""center""]

The Solver should eventually get out of this trap, but it will take a lot of effort (especially if there are even more processes on the overloaded computer). Before they do that, they might actually start moving more processes into that overloaded computer, as there is no penalty for doing so.

[NOTE]
====
Avoiding score traps does not mean that your score function should be smart enough to avoid local optima.
Leave it to the optimization algorithms to deal with the local optima.

Avoiding score traps means to avoid, for each score constraint individually, a flatlined score function.
====

[IMPORTANT]
====
Always specify the degree of infeasibility.
The business will often say ""if the solution is infeasible, it does not matter how infeasible it is."" While that is true for the business, it is not true for score calculation as it benefits from knowing how infeasible it is.
In practice, soft constraints usually do this naturally and it is just a matter of doing it for the hard constraints too.
====

There are several ways to deal with a score trap:

* Improve the score constraint to make a distinction in the score weight. For example, penalize `-1hard` for every missing CPU, instead of just `-1hard` if any CPU is missing.
* If changing the score constraint is not allowed from the business perspective, add a lower score level with a score constraint that makes such a distinction. For example, penalize `-1subsoft` for every missing CPU, on top of `-1hard` if any CPU is missing. The business ignores the subsoft score level.
* Add coarse-grained moves and union select them with the existing fine-grained moves. A coarse-grained move effectively does multiple moves to directly get out of a score trap with a single move. For example, move multiple items from the same container to another container.


[[stepLimitBenchmark]]
=== `stepLimit` benchmark

Not all score constraints have the same performance cost.
Sometimes one score constraint can kill the score calculation performance outright.
Use the xref:benchmarking-and-tweaking/benchmarking-and-tweaking.adoc#benchmarker[Benchmarker] to do a one minute run and check what happens to the score calculation speed if you comment out all but one of the score constraints.


[[fairnessScoreConstraints]]
=== Fairness score constraints

Some use cases have a business requirement to provide a fair schedule (usually as a soft score constraint), for example:

* Fairly distribute the workload amongst the employees, to avoid envy.
* Evenly distribute the workload amongst assets, to improve reliability.

Implementing such a constraint can seem difficult (especially because there are different ways to formalize fairness), but usually the _squared workload_ implementation behaves most desirable.
For each employee/asset, count the workload `w` and subtract `w²` from the score.

image::score-calculation/fairnessScoreConstraint.png[align=""center""]

As shown above, the _squared workload_ implementation guarantees that if you select two employees from a given solution and make their distribution between those two employees fairer, then the resulting new solution will have a better overall score.
Do not just use the difference from the average workload, as that can lead to unfairness, as demonstrated below.

image::score-calculation/fairnessScoreConstraintPitfall.png[align=""center""]


[NOTE]
====
Instead of the _squared workload_, it is also possible to use the https://en.wikipedia.org/wiki/Variance[variance]
(squared difference to the average) or the http://en.wikipedia.org/wiki/Standard_deviation[standard deviation]
(square root of the variance).
This has no effect on the score comparison, because the average will not change during planning.
It is just more work to implement (because the average needs to be known) and trivially slower (because the calculation is a bit longer).
====

When the workload is perfectly balanced, the user often likes to see a `0` score, instead of the distracting `-34soft` in the image above (for the last solution which is almost perfectly balanced).
To nullify this, either add the average multiplied by the number of entities to the score or instead show the variance or standard deviation in the UI.

[[constraintConfiguration]]
== Constraint configuration: adjust constraint weights dynamically

Deciding the correct <<scoreConstraintWeight,weight>> and <<scoreLevel,level>> for each constraint is not easy.
It often involves negotiating with different stakeholders and their priorities.
Furthermore, quantifying the impact of soft constraints is often a new experience for business managers, so they'll need a number of iterations to get it right.

Don't get stuck between a rock and a hard place.
Provide a UI to adjust the constraint weights and visualize the resulting solution, so the business managers can tweak the constraint weights themselves:

image::score-calculation/parameterizeTheScoreWeights.png[align=""center""]

[[createAConstraintConfiguration]]
=== Create a constraint configuration

First, create a new class to hold the constraint weights and other constraint parameters.
Annotate it with `@ConstraintConfiguration`:

[source,java,options=""nowrap""]
----
@ConstraintConfiguration
public class ConferenceConstraintConfiguration {
    ...
}
----

There will be exactly one instance of this class per planning solution.
The planning solution and the constraint configuration have a one-to-one relationship,
but they serve a different purpose, so they aren't merged into a single class.
A `@ConstraintConfiguration` class can extend a parent `@ConstraintConfiguration` class,
which can be useful in international use cases with many regional constraints.

Add the constraint configuration on the planning solution
and annotate that field or property with `@ConstraintConfigurationProvider`:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class ConferenceSolution {

    @ConstraintConfigurationProvider
    private ConferenceConstraintConfiguration constraintConfiguration;

    ...
}
----

The `@ConstraintConfigurationProvider` annotation automatically exposes the constraint configuration
as a xref:planner-configuration/planner-configuration.adoc#problemFacts[problem fact], there is no need to add a `@ProblemFactProperty` annotation.

The constraint configuration class holds the <<constraintWeight, constraint weights>>,
but it can also hold constraint parameters.
For example in conference scheduling, the minimum pause constraint has a constraint weight (like any other constraint),
but it also has a constraint parameter that defines the length of the minimum pause between two talks of the same speaker.
That pause length depends on the conference (= the planning problem):
in some big conferences 20 minutes isn't enough to go from one room to the other.
That pause length is a field in the constraint configuration without a `@ConstraintWeight` annotation.


[[constraintWeight]]
=== Add a constraint weight for each constraint

In the constraint configuration class, add a `@ConstraintWeight` field or property for each constraint:

[source,java,options=""nowrap""]
----
@ConstraintConfiguration(constraintPackage = ""...conferencescheduling.score"")
public class ConferenceConstraintConfiguration {

    @ConstraintWeight(""Speaker conflict"")
    private HardMediumSoftScore speakerConflict = HardMediumSoftScore.ofHard(10);

    @ConstraintWeight(""Theme track conflict"")
    private HardMediumSoftScore themeTrackConflict = HardMediumSoftScore.ofSoft(10);
    @ConstraintWeight(""Content conflict"")
    private HardMediumSoftScore contentConflict = HardMediumSoftScore.ofSoft(100);

    ...
}
----

The type of the constraint weights must be the same score class as xref:planner-configuration/planner-configuration.adoc#scoreOfASolution[the planning solution's score member].
For example in conference scheduling, `ConferenceSolution.getScore()` and `ConferenceConstraintConfiguration.getSpeakerConflict()`
both return a `HardMediumSoftScore`.

A constraint weight cannot be null.
Give each constraint weight a default value, but expose them in a UI so the business users can tweak them.
The example above uses the `ofHard()`, `ofMedium()` and `ofSoft()` methods to do that.
Notice how it defaults the _content conflict_ constraint as ten times more important than the _theme track conflict_ constraint.
Normally, a constraint weight only uses one score level,
but it's possible to use multiple score levels (at a small performance cost).

Each constraint has a constraint package and a constraint name, together they form the constraint id.
These connect the constraint weight with the constraint implementation.
*For each constraint weight, there must be a constraint implementation with the same package and the same name.*

* The `@ConstraintConfiguration` annotation has a `constraintPackage` property that defaults to the package of the constraint configuration class.
Most cases with xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation], need to override that because the DRLs use another package.
For example, the DRL below uses the package `...conferencescheduling.score`,
so the constraint configuration above specifies a `constraintPackage`.
Cases with xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams], normally don't need to specify it.

* The `@ConstraintWeight` annotation has a `value` which is the constraint name (for example ""Speaker conflict"").
It inherits the constraint package from the `@ConstraintConfiguration`,
but it can override that, for example `@ConstraintWeight(constraintPackage = ""...region.france"", ...)`
to use a different constraint package than some of the other weights.

So every constraint weight ends up with a constraint package and a constraint name.
Each constraint weight links with a constraint implementation,
for example in xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation]:

[source,options=""nowrap""]
----
package ...conferencescheduling.solver;

rule ""Speaker conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext);
end

rule ""Theme track conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext, ...);
end

rule ""Content conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext, ...);
end
----

Each of the constraint weights defines the score level and score weight of their constraint.
The constraint implementation calls `reward()` or `penalize()` and the constraint weight is automatically applied.

If the constraint implementation provides a match weight, that *match weight is multiplied with the constraint weight*.
For example, the _content conflict_ constraint weight defaults to `100soft`
and the constraint implementation penalizes each match based on the number of shared content tags:

[source,java,options=""nowrap""]
----
    @ConstraintWeight(""Content conflict"")
    private HardMediumSoftScore contentConflict = HardMediumSoftScore.ofSoft(100);
----

[source,options=""nowrap""]
----
rule ""Content conflict""
    when
        $talk1 : Talk(...)
        $talk2 : Talk(...)
    then
        scoreHolder.penalize(kcontext,
                $talk2.overlappingContentCount($talk1));
end
----

So when 2 overlapping talks share only 1 content tag, the score is impacted by `-100soft`.
But when 2 overlapping talks share 3 content tags, the match weight is `3`, so the score is impacted by `-300soft`.

[[explainingTheScore]]
== Explaining the score: which constraints are broken?

The easiest way to explain the score during development is to print the return value of `explainScore()`, but only use that method for diagnostic purposes:

[source,java,options=""nowrap""]
----
System.out.println(scoreManager.explainScore(solution));
----

For example in conference scheduling, this prints that talk `S51` is responsible for breaking the hard constraint `Speaker required room tag`:

----
Explanation of score (-1hard/-806soft):
    Constraint match totals:
        -1hard: constraint (Speaker required room tag) has 1 matches:
            -1hard: justifications ([S51])
        -340soft: constraint (Theme track conflict) has 32 matches:
            -20soft: justifications ([S68, S66])
            -20soft: justifications ([S61, S44])
            ...
        ...
    Indictments (top 5 of 72):
        -1hard/-22soft: justification (S51) has 12 matches:
            -1hard: constraint (Speaker required room tag)
            -10soft: constraint (Theme track conflict)
            ...
        ...
----

[IMPORTANT]
====
Do not attempt to parse this string or use it in your UI or exposed services.
Instead use the ConstraintMatch API below and do it properly.
====

[[usingScoreCalculationOutsideTheSolver]]
=== Using score calculation outside the `Solver`

If other parts of your application, for example your webUI, need to calculate the score of a solution, use the `ScoreManager` API:

[source,java,options=""nowrap""]
----
ScoreManager<CloudBalance, HardSoftScore> scoreManager = ScoreManager.create(solverFactory);
ScoreExplanation<CloudBalance, HardSoftScore> scoreExplanation = scoreManager.explain(cloudBalance);
----

Then use it when you need to calculate the `Score` of a solution:

[source,java,options=""nowrap""]
----
HardSoftScore score = scoreExplanation.getScore();
----

Furthermore, the `ScoreExplanation` can help explain the score through constraint match totals and/or indictments:

image::score-calculation/scoreVisualization.png[align=""center""]

[[constraintMatchTotal]]
=== Constraint match total: break down the score by constraint

To break down the score per constraint, get the ``ConstraintMatchTotal``s from the ``ScoreExplanation``:

[source,java,options=""nowrap""]
----
Collection<ConstraintMatchTotal<HardSoftScore>> constraintMatchTotals = scoreExplanation.getConstraintMatchTotalMap().values();
for (ConstraintMatchTotal<HardSoftScore> constraintMatchTotal : constraintMatchTotals) {
    String constraintName = constraintMatchTotal.getConstraintName();
    // The score impact of that constraint
    HardSoftScore totalScore = constraintMatchTotal.getScore();

    for (ConstraintMatch<HardSoftScore> constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
        List<Object> justificationList = constraintMatch.getJustificationList();
        HardSoftScore score = constraintMatch.getScore();
        ...
    }
}
----

Each `ConstraintMatchTotal` represents one constraint and has a part of the overall score.
The sum of all the `ConstraintMatchTotal.getScore()` equals the overall score.

[NOTE]
====
xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams] and xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation] supports constraint matches automatically, but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
<<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
====

[[indictmentHeatMap]]
=== Indictment heat map: visualize the hot planning entities

To show a heat map in the UI that highlights the planning entities and problem facts have an impact on the ``Score``, get the `Indictment` map from the ``ScoreExplanation``:

[source,java,options=""nowrap""]
----
Map<Object, Indictment<HardSoftScore>> indictmentMap = scoreExplanation.getIndictmentMap();
for (CloudProcess process : cloudBalance.getProcessList()) {
    Indictment<HardSoftScore> indictment = indictmentMap.get(process);
    if (indictment == null) {
        continue;
    }
    // The score impact of that planning entity
    HardSoftScore totalScore = indictment.getScore();

    for (ConstraintMatch<HardSoftScore> constraintMatch : indictment.getConstraintMatchSet()) {
        String constraintName = constraintMatch.getConstraintName();
        HardSoftScore score = constraintMatch.getScore();
        ...
    }
}
----

Each `Indictment` is the sum of all constraints where that justification object is involved with.
The sum of all the `Indictment.getScoreTotal()` differs from the overall score, because multiple ``Indictment``s can share the same `ConstraintMatch`.

[NOTE]
====
xref:constraint-streams/constraint-streams.adoc#constraintStreams[Constraint streams] and xref:drools-score-calculation/drools-score-calculation.adoc#droolsScoreCalculation[Drools score calculation] supports constraint matches automatically, but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
<<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
====


[[testingScoreConstraints]]
== Testing score constraints

It's recommended to write a unit test for each score constraint individually to check that it behaves correctly.
Different score calculation types come with different tools for testing.
For more, see xref:constraint-streams/constraint-streams.adoc#constraintStreamsTesting[testing Constraint Streams] or
xref:drools-score-calculation/drools-score-calculation.adoc#testingDroolsConstraints[testing Drools constraints].
",12270,False,2171.9442003326503,median
"/*
 * Copyright (C) 2005 - 2013 MaNGOS <http://www.getmangos.com/>
 *
 * Copyright (C) 2008 - 2013 Trinity <http://www.trinitycore.org/>
 *
 * Copyright (C) 2010 - 2013 ProjectSkyfire <http://www.projectskyfire.org/>
 *
 * Copyright (C) 2011 - 2013 ArkCORE <http://www.arkania.net/>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include ""gamePCH.h""
#include ""LootMgr.h""
#include ""Log.h""
#include ""ObjectMgr.h""

#include ""World.h""
#include ""Util.h""
#include ""SharedDefines.h""
#include ""SpellMgr.h""
#include ""Group.h""

static Rates const qualityToRate[MAX_ITEM_QUALITY] =
{ RATE_DROP_ITEM_POOR,          // ITEM_QUALITY_POOR
RATE_DROP_ITEM_NORMAL,          // ITEM_QUALITY_NORMAL
RATE_DROP_ITEM_UNCOMMON,          // ITEM_QUALITY_UNCOMMON
RATE_DROP_ITEM_RARE,          // ITEM_QUALITY_RARE
RATE_DROP_ITEM_EPIC,          // ITEM_QUALITY_EPIC
RATE_DROP_ITEM_LEGENDARY,          // ITEM_QUALITY_LEGENDARY
RATE_DROP_ITEM_ARTIFACT,          // ITEM_QUALITY_ARTIFACT
};

LootStore LootTemplates_Creature(""creature_loot_template"", ""creature entry"", true);
LootStore LootTemplates_Disenchant(""disenchant_loot_template"", ""item disenchant id"", true);
LootStore LootTemplates_Fishing(""fishing_loot_template"", ""area id"", true);
LootStore LootTemplates_Gameobject(""gameobject_loot_template"", ""gameobject entry"", true);
LootStore LootTemplates_Item(""item_loot_template"", ""item entry"", true);
LootStore LootTemplates_Mail(""mail_loot_template"", ""mail template id"", false);
LootStore LootTemplates_Milling(""milling_loot_template"", ""item entry (herb)"", true);
LootStore LootTemplates_Pickpocketing(""pickpocketing_loot_template"", ""creature pickpocket lootid"", true);
LootStore LootTemplates_Prospecting(""prospecting_loot_template"", ""item entry (ore)"", true);
LootStore LootTemplates_Reference(""reference_loot_template"", ""reference id"", false);
LootStore LootTemplates_Skinning(""skinning_loot_template"", ""creature skinning id"", true);
LootStore LootTemplates_Spell(""spell_loot_template"", ""spell id (random item creating)"", false);

class LootTemplate::LootGroup          // A set of loot definitions for items (refs are not allowed)
{
public:
    void AddEntry (LootStoreItem& item);          // Adds an entry to the group (at loading stage)
    bool HasQuestDrop () const;          // True if group includes at least 1 quest drop entry
    bool HasQuestDropForPlayer (Player const * player) const;
    // The same for active quests of the player
    void Process (Loot& loot, uint16 lootMode) const;          // Rolls an item from the group (if any) and adds the item to the loot
    float RawTotalChance () const;          // Overall chance for the group (without equal chanced items)
    float TotalChance () const;          // Overall chance for the group

    void Verify (LootStore const& lootstore, uint32 id, uint8 group_id) const;
    void CollectLootIds (LootIdSet& set) const;
    void CheckLootRefs (LootTemplateMap const& store, LootIdSet* ref_set) const;
    LootStoreItemList * GetExplicitlyChancedItemList ()
    {
        return &ExplicitlyChanced;
    }
    LootStoreItemList * GetEqualChancedItemList ()
    {
        return &EqualChanced;
    }
    void CopyConditions (ConditionList conditions);
private:
    LootStoreItemList ExplicitlyChanced;          // Entries with chances defined in DB
    LootStoreItemList EqualChanced;          // Zero chances - every entry takes the same chance

    LootStoreItem const * Roll () const;          // Rolls an item from the group, returns NULL if all miss their chances
};

//Remove all data and free all memory
void LootStore::Clear ()
{
    for (LootTemplateMap::const_iterator itr = m_LootTemplates.begin(); itr != m_LootTemplates.end(); ++itr)
        delete itr->second;
    m_LootTemplates.clear();
}

// Checks validity of the loot store
// Actual checks are done within LootTemplate::Verify() which is called for every template
void LootStore::Verify () const
{
    for (LootTemplateMap::const_iterator i = m_LootTemplates.begin(); i != m_LootTemplates.end(); ++i)
        i->second->Verify(*this, i->first);
}

// Loads a *_loot_template DB table into loot store
// All checks of the loaded template are called from here, no error reports at loot generation required
uint32 LootStore::LoadLootTable ()
{
    LootTemplateMap::const_iterator tab;

    // Clearing store (for reloading case)
    Clear();

    //                                                  0     1            2               3         4         5             6
    QueryResult result = WorldDatabase.PQuery(""SELECT entry, item, ChanceOrQuestChance, lootmode, groupid, mincountOrRef, maxcount FROM %s"", GetName());

    if (!result)
    {
        return 0;
    }

    uint32 count = 0;

    do
    {
        Field *fields = result->Fetch();

        uint32 entry = fields[0].GetUInt32();
        uint32 item = fields[1].GetUInt32();
        float chanceOrQuestChance = fields[2].GetFloat();
        uint16 lootmode = fields[3].GetUInt16();
        uint8 group = fields[4].GetUInt8();
        int32 mincountOrRef = fields[5].GetInt32();
        int32 maxcount = fields[6].GetInt32();

        if (maxcount > std::numeric_limits < uint8 > ::max())
        {
            sLog->outErrorDb(""Table '%s' entry %d item %d: maxcount value (%u) to large. must be less %u - skipped"", GetName(), entry, item, maxcount, std::numeric_limits < uint8 > ::max());
            continue;          // error already printed to log/console.
        }

        LootStoreItem storeitem = LootStoreItem(item, chanceOrQuestChance, lootmode, group, mincountOrRef, maxcount);

        if (!storeitem.IsValid(*this, entry))          // Validity checks
            continue;

        // Looking for the template of the entry
        // often entries are put together
        if (m_LootTemplates.empty() || tab->first != entry)
        {
            // Searching the template (in case template Id changed)
            tab = m_LootTemplates.find(entry);
            if (tab == m_LootTemplates.end())
            {
                std::pair<LootTemplateMap::iterator, bool> pr = m_LootTemplates.insert(LootTemplateMap::value_type(entry, new LootTemplate));
                tab = pr.first;
            }
        }
        // else is empty - template Id and iter are the same
        // finally iter refers to already existed or just created <entry, LootTemplate>

        // Adds current row to the template
        tab->second->AddEntry(storeitem);
        ++count;
    }
    while (result->NextRow());

    Verify();          // Checks validity of the loot store

    return count;
}

bool LootStore::HaveQuestLootFor (uint32 loot_id) const
{
    LootTemplateMap::const_iterator itr = m_LootTemplates.find(loot_id);
    if (itr == m_LootTemplates.end())
        return false;

    // scan loot for quest items
    return itr->second->HasQuestDrop(m_LootTemplates);
}

bool LootStore::HaveQuestLootForPlayer (uint32 loot_id, Player* player) const
{
    LootTemplateMap::const_iterator tab = m_LootTemplates.find(loot_id);
    if (tab != m_LootTemplates.end())
        if (tab->second->HasQuestDropForPlayer(m_LootTemplates, player))
            return true;

    return false;
}

void LootStore::ResetConditions ()
{
    for (LootTemplateMap::iterator itr = m_LootTemplates.begin(); itr != m_LootTemplates.end(); ++itr)
    {
        ConditionList empty;
        (*itr).second->CopyConditions(empty);
    }
}

LootTemplate const* LootStore::GetLootFor (uint32 loot_id) const
{
    LootTemplateMap::const_iterator tab = m_LootTemplates.find(loot_id);

    if (tab == m_LootTemplates.end())
        return NULL;

    return tab->second;
}

LootTemplate* LootStore::GetLootForConditionFill (uint32 loot_id)
{
    LootTemplateMap::iterator tab = m_LootTemplates.find(loot_id);

    if (tab == m_LootTemplates.end())
        return NULL;

    return tab->second;
}

uint32 LootStore::LoadAndCollectLootIds (LootIdSet& ids_set)
{
    uint32 count = LoadLootTable();

    for (LootTemplateMap::const_iterator tab = m_LootTemplates.begin(); tab != m_LootTemplates.end(); ++tab)
        ids_set.insert(tab->first);

    return count;
}

void LootStore::CheckLootRefs (LootIdSet* ref_set) const
{
    for (LootTemplateMap::const_iterator ltItr = m_LootTemplates.begin(); ltItr != m_LootTemplates.end(); ++ltItr)
        ltItr->second->CheckLootRefs(m_LootTemplates, ref_set);
}

void LootStore::ReportUnusedIds (LootIdSet const& ids_set) const
{
    // all still listed ids isn't referenced
    for (LootIdSet::const_iterator itr = ids_set.begin(); itr != ids_set.end(); ++itr)
        sLog->outErrorDb(""Table '%s' entry %d isn't %s and not referenced from loot, and then useless."", GetName(), *itr, GetEntryName());
}

void LootStore::ReportNotExistedId (uint32 id) const
{
    sLog->outErrorDb(""Table '%s' entry %d (%s) not exist but used as loot id in DB."", GetName(), id, GetEntryName());
}

//
// --------- LootStoreItem ---------
//

// Checks if the entry (quest, non-quest, reference) takes it's chance (at loot generation)
// RATE_DROP_ITEMS is no longer used for all types of entries
bool LootStoreItem::Roll (bool rate) const
{
    if (chance >= 100.0f)
        return true;

    if (mincountOrRef < 0)          // reference case
        return roll_chance_f(chance * (rate ? sWorld->getRate(RATE_DROP_ITEM_REFERENCED) : 1.0f));

    ItemPrototype const *pProto = ObjectMgr::GetItemPrototype(itemid);

    float qualityModifier = pProto && rate ? sWorld->getRate(qualityToRate[pProto->Quality]) : 1.0f;

    return roll_chance_f(chance * qualityModifier);
}

// Checks correctness of values
bool LootStoreItem::IsValid (LootStore const& store, uint32 entry) const
{
    if (group >= 1 << 7)          // it stored in 7 bit field
    {
        sLog->outErrorDb(""Table '%s' entry %d item %d: group (%u) must be less %u - skipped"", store.GetName(), entry, itemid, group, 1 << 7);
        return false;
    }

    if (mincountOrRef == 0)
    {
        sLog->outErrorDb(""Table '%s' entry %d item %d: wrong mincountOrRef (%d) - skipped"", store.GetName(), entry, itemid, mincountOrRef);
        return false;
    }

    if (mincountOrRef > 0)          // item (quest or non-quest) entry, maybe grouped
    {
        ItemPrototype const *proto = ObjectMgr::GetItemPrototype(itemid);
        if (!proto)
        {
            sLog->outErrorDb(""Table '%s' entry %d item %d: item entry not listed in `item_template` - skipped"", store.GetName(), entry, itemid);
            return false;
        }

        if (chance == 0 && group == 0)          // Zero chance is allowed for grouped entries only
        {
            sLog->outErrorDb(""Table '%s' entry %d item %d: equal-chanced grouped entry, but group not defined - skipped"", store.GetName(), entry, itemid);
            return false;
        }

        if (chance != 0 && chance < 0.000001f)          // loot with low chance
        {
            sLog->outErrorDb(""Table '%s' entry %d item %d: low chance (%f) - skipped"", store.GetName(), entry, itemid, chance);
            return false;
        }

        if (maxcount < mincountOrRef)          // wrong max count
        {
            sLog->outErrorDb(""Table '%s' entry %d item %d: max count (%u) less that min count (%i) - skipped"", store.GetName(), entry, itemid, int32(maxcount), mincountOrRef);
            return false;
        }
    }
    else          // mincountOrRef < 0
    {
        if (needs_quest)
            sLog->outErrorDb(""Table '%s' entry %d item %d: quest chance will be treated as non-quest chance"", store.GetName(), entry, itemid);
        else if (chance == 0)          // no chance for the reference
        {
            sLog->outErrorDb(""Table '%s' entry %d item %d: zero chance is specified for a reference, skipped"", store.GetName(), entry, itemid);
            return false;
        }
    }
    return true;          // Referenced template existence is checked at whole store level
}

//
// --------- LootItem ---------
//

// Constructor, copies most fields from LootStoreItem and generates random count
LootItem::LootItem (LootStoreItem const& li)
{
    itemid = li.itemid;
    conditions = li.conditions;

    ItemPrototype const* proto = ObjectMgr::GetItemPrototype(itemid);
    freeforall = proto && (proto->Flags & ITEM_PROTO_FLAG_PARTY_LOOT);

    needs_quest = li.needs_quest;

    count = urand(li.mincountOrRef, li.maxcount);          // constructor called for mincountOrRef > 0 only
    randomSuffix = GenerateEnchSuffixFactor(itemid);
    randomPropertyId = Item::GenerateItemRandomPropertyId(itemid);
    is_looted = 0;
    is_blocked = 0;
    is_underthreshold = 0;
    is_counted = 0;
}

// Basic checks for player/item compatibility - if false no chance to see the item in the loot
bool LootItem::AllowedForPlayer (Player const * player) const
{
    // DB conditions check
    if (!sConditionMgr->IsPlayerMeetToConditions(const_cast<Player*>(player), conditions))
        return false;

    ItemPrototype const *pProto = ObjectMgr::GetItemPrototype(itemid);
    if (!pProto)
        return false;

    // not show loot for players without profession or those who already know the recipe
    if ((pProto->Flags & ITEM_PROTO_FLAG_SMART_LOOT) && (!player->HasSkill(pProto->RequiredSkill) || player->HasSpell(pProto->Spells[1].SpellId)))
        return false;

    // not show loot for not own team
    if ((pProto->Flags2 & ITEM_FLAGS_EXTRA_HORDE_ONLY) && player->GetTeam() != HORDE)
        return false;

    if ((pProto->Flags2 & ITEM_FLAGS_EXTRA_ALLIANCE_ONLY) && player->GetTeam() != ALLIANCE)
        return false;

    if (needs_quest)
    {
        // Checking quests for quest-only drop (check only quests requirements in this case)
        if (!player->HasQuestForItem(itemid))
            return false;
    }
    else
    {
        // Not quest only drop (check quest starting items for already accepted non-repeatable quests)
        if (pProto->StartQuest && player->GetQuestStatus(pProto->StartQuest) != QUEST_STATUS_NONE && !player->HasQuestForItem(itemid))
            return false;
    }

    return true;
}

void LootItem::AddAllowedLooter (const Player *player)
{
    allowedGUIDs.insert(player->GetGUIDLow());
}

//
// --------- Loot ---------
//

// Inserts the item into the loot (called by LootTemplate processors)
void Loot::AddItem (LootStoreItem const & item)
{
    if (item.needs_quest)          // Quest drop
    {
        if (quest_items.size() < MAX_NR_QUEST_ITEMS)
            quest_items.push_back(LootItem(item));
    }
    else if (items.size() < MAX_NR_LOOT_ITEMS)          // Non-quest drop
    {
        items.push_back(LootItem(item));

        // non-conditional one-player only items are counted here,
        // free for all items are counted in FillFFALoot(),
        // non-ffa conditionals are counted in FillNonQuestNonFFAConditionalLoot()
        if (item.conditions.empty())
        {
            ItemPrototype const* proto = ObjectMgr::GetItemPrototype(item.itemid);
            if (!proto || (proto->Flags & ITEM_PROTO_FLAG_PARTY_LOOT) == 0)
                ++unlootedCount;
        }
    }
}

// Calls processor of corresponding LootTemplate (which handles everything including references)
bool Loot::FillLoot (uint32 lootId, LootStore const& store, Player* lootOwner, bool personal, bool noEmptyError, uint16 lootMode /*= LOOT_MODE_DEFAULT*/)
{
    // Must be provided
    if (!lootOwner)
        return false;

    LootTemplate const* tab = store.GetLootFor(lootId);

    if (!tab)
    {
        if (!noEmptyError)
            sLog->outErrorDb(""Table '%s' loot id #%u used but it doesn't have records."", store.GetName(), lootId);
        return false;
    }

    items.reserve(MAX_NR_LOOT_ITEMS);
    quest_items.reserve(MAX_NR_QUEST_ITEMS);

    tab->Process(*this, store.IsRatesAllowed(), lootMode);          // Processing is done there, callback via Loot::AddItem()

    // Setting access rights for group loot case
    Group * pGroup = lootOwner->GetGroup();
    if (!personal && pGroup)
    {
        roundRobinPlayer = lootOwner->GetGUID();

        for (GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
            if (Player* pl = itr->getSource())          // should actually be looted object instead of lootOwner but looter has to be really close so doesnt really matter
                FillNotNormalLootFor(pl, pl->IsAtGroupRewardDistance(lootOwner));

        for (uint8 i = 0; i < items.size(); ++i)
        {
            if (ItemPrototype const *proto = sItemStorage.LookupEntry<ItemPrototype>(items[i].itemid))
                if (proto->Quality < uint32(pGroup->GetLootThreshold()))
                    items[i].is_underthreshold = true;
        }
    }
    // ... for personal loot
    else
        FillNotNormalLootFor(lootOwner, true);

    return true;
}

void Loot::FillNotNormalLootFor (Player* pl, bool withCurrency)
{
    uint32 plguid = pl->GetGUIDLow();

    QuestItemMap::const_iterator qmapitr = PlayerQuestItems.find(plguid);
    if (qmapitr == PlayerQuestItems.end())
        FillQuestLoot(pl);

    qmapitr = PlayerFFAItems.find(plguid);
    if (qmapitr == PlayerFFAItems.end())
        FillFFALoot(pl);

    qmapitr = PlayerNonQuestNonFFAConditionalItems.find(plguid);
    if (qmapitr == PlayerNonQuestNonFFAConditionalItems.end())
        FillNonQuestNonFFAConditionalLoot(pl);

    // if not auto-processed player will have to come and pick it up manually
    if (!withCurrency)
        return;

    // Process currency items
    uint32 max_slot = GetMaxSlotInLootFor(pl);
    LootItem const *item = NULL;
    uint32 itemsSize = uint32(items.size());
    for (uint32 i = 0; i < max_slot; ++i)
    {
        if (i < items.size())
            item = &items[i];
        else
            item = &quest_items[i - itemsSize];

        if (!item->is_looted && item->freeforall && item->AllowedForPlayer(pl))
            if (ItemPrototype const* proto = ObjectMgr::GetItemPrototype(item->itemid))
                if (proto->BagFamily & BAG_FAMILY_MASK_CURRENCY_TOKENS)
                    pl->StoreLootItem(i, this);
    }
}

QuestItemList* Loot::FillFFALoot (Player* player)
{
    QuestItemList *ql = new QuestItemList();

    for (uint8 i = 0; i < items.size(); ++i)
    {
        LootItem &item = items[i];
        if (!item.is_looted && item.freeforall && item.AllowedForPlayer(player))
        {
            ql->push_back(QuestItem(i));
            ++unlootedCount;
        }
    }
    if (ql->empty())
    {
        delete ql;
        return NULL;
    }

    PlayerFFAItems[player->GetGUIDLow()] = ql;
    return ql;
}

QuestItemList* Loot::FillQuestLoot (Player* player)
{
    if (items.size() == MAX_NR_LOOT_ITEMS)
        return NULL;
    QuestItemList *ql = new QuestItemList();

    for (uint8 i = 0; i < quest_items.size(); ++i)
    {
        LootItem &item = quest_items[i];
        if (!item.is_looted && item.AllowedForPlayer(player))
        {
            ql->push_back(QuestItem(i));

            // questitems get blocked when they first appear in a
            // player's quest vector
            //
            // increase once if one looter only, looter-times if free for all
            if (item.freeforall || !item.is_blocked)
                ++unlootedCount;

            item.is_blocked = true;

            if (items.size() + ql->size() == MAX_NR_LOOT_ITEMS)
                break;
        }
    }
    if (ql->empty())
    {
        delete ql;
        return NULL;
    }

    PlayerQuestItems[player->GetGUIDLow()] = ql;
    return ql;
}

QuestItemList* Loot::FillNonQuestNonFFAConditionalLoot (Player* player)
{
    QuestItemList *ql = new QuestItemList();

    for (uint8 i = 0; i < items.size(); ++i)
    {
        LootItem &item = items[i];
        if (!item.is_looted && !item.freeforall && item.AllowedForPlayer(player))
        {
            item.AddAllowedLooter(player);
            if (!item.conditions.empty())
            {
                ql->push_back(QuestItem(i));
                if (!item.is_counted)
                {
                    ++unlootedCount;
                    item.is_counted = true;
                }
            }
        }
    }
    if (ql->empty())
    {
        delete ql;
        return NULL;
    }

    PlayerNonQuestNonFFAConditionalItems[player->GetGUIDLow()] = ql;
    return ql;
}

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

void Loot::NotifyItemRemoved (uint8 lootIndex)
{
    // notify all players that are looting this that the item was removed
    // convert the index to the slot the player sees
    std::set<uint64>::iterator i_next;
    for (std::set<uint64>::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* pl = ObjectAccessor::FindPlayer(*i))
            pl->SendNotifyLootItemRemoved(lootIndex);
        else
            PlayersLooting.erase(i);
    }
}

void Loot::NotifyMoneyRemoved ()
{
    // notify all players that are looting this that the money was removed
    std::set<uint64>::iterator i_next;
    for (std::set<uint64>::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* pl = ObjectAccessor::FindPlayer(*i))
            pl->SendNotifyLootMoneyRemoved();
        else
            PlayersLooting.erase(i);
    }
}

void Loot::NotifyQuestItemRemoved (uint8 questIndex)
{
    // when a free for all questitem is looted
    // all players will get notified of it being removed
    // (other questitems can be looted by each group member)
    // bit inefficient but isn't called often

    std::set<uint64>::iterator i_next;
    for (std::set<uint64>::iterator i = PlayersLooting.begin(); i != PlayersLooting.end(); i = i_next)
    {
        i_next = i;
        ++i_next;
        if (Player* pl = ObjectAccessor::FindPlayer(*i))
        {
            QuestItemMap::const_iterator pq = PlayerQuestItems.find(pl->GetGUIDLow());
            if (pq != PlayerQuestItems.end() && pq->second)
            {
                // find where/if the player has the given item in it's vector
                QuestItemList& pql = *pq->second;

                uint8 j;
                for (j = 0; j < pql.size(); ++j)
                    if (pql[j].index == questIndex)
                        break;

                if (j < pql.size())
                    pl->SendNotifyLootItemRemoved(items.size() + j);
            }
        }
        else
            PlayersLooting.erase(i);
    }
}

void Loot::generateMoneyLoot (uint32 minAmount, uint32 maxAmount)
{
    if (maxAmount > 0)
    {
        if (maxAmount <= minAmount)
            gold = uint32(maxAmount * sWorld->getRate(RATE_DROP_MONEY));
        else if ((maxAmount - minAmount) < 32700)
            gold = uint32(urand(minAmount, maxAmount) * sWorld->getRate(RATE_DROP_MONEY));
        else
            gold = uint32(urand(minAmount >> 8, maxAmount >> 8) * sWorld->getRate(RATE_DROP_MONEY)) << 8;
    }
}

LootItem* Loot::LootItemInSlot (uint32 lootSlot, Player* player, QuestItem **qitem, QuestItem **ffaitem, QuestItem **conditem)
{
    LootItem* item = NULL;
    bool is_looted = true;
    if (lootSlot >= items.size())
    {
        uint32 questSlot = lootSlot - items.size();
        QuestItemMap::const_iterator itr = PlayerQuestItems.find(player->GetGUIDLow());
        if (itr != PlayerQuestItems.end() && questSlot < itr->second->size())
        {
            QuestItem *qitem2 = &itr->second->at(questSlot);
            if (qitem)
                *qitem = qitem2;
            item = &quest_items[qitem2->index];
            is_looted = qitem2->is_looted;
        }
    }
    else
    {
        item = &items[lootSlot];
        is_looted = item->is_looted;
        if (item->freeforall)
        {
            QuestItemMap::const_iterator itr = PlayerFFAItems.find(player->GetGUIDLow());
            if (itr != PlayerFFAItems.end())
            {
                for (QuestItemList::const_iterator iter = itr->second->begin(); iter != itr->second->end(); ++iter)
                    if (iter->index == lootSlot)
                    {
                        QuestItem *ffaitem2 = (QuestItem*) &(*iter);
                        if (ffaitem)
                            *ffaitem = ffaitem2;
                        is_looted = ffaitem2->is_looted;
                        break;
                    }
            }
        }
        else if (!item->conditions.empty())
        {
            QuestItemMap::const_iterator itr = PlayerNonQuestNonFFAConditionalItems.find(player->GetGUIDLow());
            if (itr != PlayerNonQuestNonFFAConditionalItems.end())
            {
                for (QuestItemList::const_iterator iter = itr->second->begin(); iter != itr->second->end(); ++iter)
                {
                    if (iter->index == lootSlot)
                    {
                        QuestItem *conditem2 = (QuestItem*) &(*iter);
                        if (conditem)
                            *conditem = conditem2;
                        is_looted = conditem2->is_looted;
                        break;
                    }
                }
            }
        }
    }

    // Player Bind to instance on loot
    if (player->HasPendingBind())
        player->BindToInstance();

    if (is_looted)
        return NULL;

    return item;
}

uint32 Loot::GetMaxSlotInLootFor (Player* player) const
{
    QuestItemMap::const_iterator itr = PlayerQuestItems.find(player->GetGUIDLow());
    return items.size() + (itr != PlayerQuestItems.end() ? itr->second->size() : 0);
}

// return true if there is any FFA, quest or conditional item for the player.
bool Loot::hasItemFor (Player* player) const
{
    QuestItemMap const& lootPlayerQuestItems = GetPlayerQuestItems();
    QuestItemMap::const_iterator q_itr = lootPlayerQuestItems.find(player->GetGUIDLow());
    if (q_itr != lootPlayerQuestItems.end())
    {
        QuestItemList *q_list = q_itr->second;
        for (QuestItemList::const_iterator qi = q_list->begin(); qi != q_list->end(); ++qi)
        {
            const LootItem &item = quest_items[qi->index];
            if (!qi->is_looted && !item.is_looted)
                return true;
        }
    }

    QuestItemMap const& lootPlayerFFAItems = GetPlayerFFAItems();
    QuestItemMap::const_iterator ffa_itr = lootPlayerFFAItems.find(player->GetGUIDLow());
    if (ffa_itr != lootPlayerFFAItems.end())
    {
        QuestItemList *ffa_list = ffa_itr->second;
        for (QuestItemList::const_iterator fi = ffa_list->begin(); fi != ffa_list->end(); ++fi)
        {
            const LootItem &item = items[fi->index];
            if (!fi->is_looted && !item.is_looted)
                return true;
        }
    }

    QuestItemMap const& lootPlayerNonQuestNonFFAConditionalItems = GetPlayerNonQuestNonFFAConditionalItems();
    QuestItemMap::const_iterator nn_itr = lootPlayerNonQuestNonFFAConditionalItems.find(player->GetGUIDLow());
    if (nn_itr != lootPlayerNonQuestNonFFAConditionalItems.end())
    {
        QuestItemList *conditional_list = nn_itr->second;
        for (QuestItemList::const_iterator ci = conditional_list->begin(); ci != conditional_list->end(); ++ci)
        {
            const LootItem &item = items[ci->index];
            if (!ci->is_looted && !item.is_looted)
                return true;
        }
    }

    return false;
}

// return true if there is any item over the group threshold (i.e. not underthreshold).
bool Loot::hasOverThresholdItem () const
{
    for (uint8 i = 0; i < items.size(); ++i)
    {
        if (!items[i].is_looted && !items[i].is_underthreshold && !items[i].freeforall)
            return true;
    }

    return false;
}

ByteBuffer& operator<< (ByteBuffer& b, LootItem const& li)
{
    b << uint32(li.itemid);
    b << uint32(li.count);          // nr of items of this type
    b << uint32(ObjectMgr::GetItemPrototype(li.itemid)->DisplayInfoID);
    b << uint32(li.randomSuffix);
    b << uint32(li.randomPropertyId);
    //b << uint8(0);                                        // slot type - will send after this function call
    return b;
}

ByteBuffer& operator<< (ByteBuffer& b, LootView const& lv)
{
    if (lv.permission == NONE_PERMISSION)
    {
        b << uint32(0);          //gold
        b << uint8(0);          // item count
        return b;          // nothing output more
    }

    Loot &l = lv.loot;

    uint8 itemsShown = 0;

    //gold
    b << uint32(l.gold);

    size_t count_pos = b.wpos();          // pos of item count byte
    b << uint8(0);          // item count placeholder
    b << uint8(0);          // unk 4.0.x

    switch (lv.permission)
    {
    case GROUP_PERMISSION:
    {
        // if you are not the round-robin group looter, you can only see
        // blocked rolled items and quest items, and !ffa items
        for (uint8 i = 0; i < l.items.size(); ++i)
        {
            if (!l.items[i].is_looted && !l.items[i].freeforall && l.items[i].conditions.empty() && l.items[i].AllowedForPlayer(lv.viewer))
            {
                uint8 slot_type;

                if (l.items[i].is_blocked)
                    slot_type = LOOT_SLOT_TYPE_ROLL_ONGOING;
                else if (l.roundRobinPlayer == 0 || !l.items[i].is_underthreshold || lv.viewer->GetGUID() == l.roundRobinPlayer)
                {
                    // no round robin owner or he has released the loot
                    // or it IS the round robin group owner
                    // => item is lootable
                    slot_type = LOOT_SLOT_TYPE_ALLOW_LOOT;
                }
                else
                    // item shall not be displayed.
                    continue;

                b << uint8(i) << l.items[i];
                b << uint8(slot_type);
                ++itemsShown;
            }
        }
        break;
    }
    case ROUND_ROBIN_PERMISSION:
    {
        for (uint8 i = 0; i < l.items.size(); ++i)
        {
            if (!l.items[i].is_looted && !l.items[i].freeforall && l.items[i].conditions.empty() && l.items[i].AllowedForPlayer(lv.viewer))
            {
                if (l.roundRobinPlayer != 0 && lv.viewer->GetGUID() != l.roundRobinPlayer)
                    // item shall not be displayed.
                    continue;

                b << uint8(i) << l.items[i];
                b << uint8(LOOT_SLOT_TYPE_ALLOW_LOOT);
                ++itemsShown;
            }
        }
        break;
    }
    case ALL_PERMISSION:
    case MASTER_PERMISSION:
    case OWNER_PERMISSION:
    {
        uint8 slot_type = LOOT_SLOT_TYPE_ALLOW_LOOT;
        switch (lv.permission)
        {
        case MASTER_PERMISSION:
            slot_type = LOOT_SLOT_TYPE_MASTER;
            break;
        case OWNER_PERMISSION:
            slot_type = LOOT_SLOT_TYPE_OWNER;
            break;
        default:
            break;
        }

        for (uint8 i = 0; i < l.items.size(); ++i)
        {
            if (!l.items[i].is_looted && !l.items[i].freeforall && l.items[i].conditions.empty() && l.items[i].AllowedForPlayer(lv.viewer))
            {
                b << uint8(i) << l.items[i];
                b << uint8(slot_type);
                ++itemsShown;
            }
        }
        break;
    }
    default:
        return b;          // nothing output more
    }

    LootSlotType slotType = lv.permission == OWNER_PERMISSION ? LOOT_SLOT_TYPE_OWNER : LOOT_SLOT_TYPE_ALLOW_LOOT;
    QuestItemMap const& lootPlayerQuestItems = l.GetPlayerQuestItems();
    QuestItemMap::const_iterator q_itr = lootPlayerQuestItems.find(lv.viewer->GetGUIDLow());
    if (q_itr != lootPlayerQuestItems.end())
    {
        QuestItemList *q_list = q_itr->second;
        for (QuestItemList::const_iterator qi = q_list->begin(); qi != q_list->end(); ++qi)
        {
            LootItem &item = l.quest_items[qi->index];
            if (!qi->is_looted && !item.is_looted)
            {
                b << uint8(l.items.size() + (qi - q_list->begin()));
                b << item;
                b << uint8(slotType);
                ++itemsShown;
            }
        }
    }

    QuestItemMap const& lootPlayerFFAItems = l.GetPlayerFFAItems();
    QuestItemMap::const_iterator ffa_itr = lootPlayerFFAItems.find(lv.viewer->GetGUIDLow());
    if (ffa_itr != lootPlayerFFAItems.end())
    {
        QuestItemList *ffa_list = ffa_itr->second;
        for (QuestItemList::const_iterator fi = ffa_list->begin(); fi != ffa_list->end(); ++fi)
        {
            LootItem &item = l.items[fi->index];
            if (!fi->is_looted && !item.is_looted)
            {
                b << uint8(fi->index);
                b << item;
                b << uint8(slotType);
                ++itemsShown;
            }
        }
    }

    QuestItemMap const& lootPlayerNonQuestNonFFAConditionalItems = l.GetPlayerNonQuestNonFFAConditionalItems();
    QuestItemMap::const_iterator nn_itr = lootPlayerNonQuestNonFFAConditionalItems.find(lv.viewer->GetGUIDLow());
    if (nn_itr != lootPlayerNonQuestNonFFAConditionalItems.end())
    {
        QuestItemList *conditional_list = nn_itr->second;
        for (QuestItemList::const_iterator ci = conditional_list->begin(); ci != conditional_list->end(); ++ci)
        {
            LootItem &item = l.items[ci->index];
            if (!ci->is_looted && !item.is_looted)
            {
                b << uint8(ci->index);
                b << item;
                b << uint8(slotType);
                ++itemsShown;
            }
        }
    }

    //update number of items shown
    b.put<uint8>(count_pos, itemsShown);

    return b;
}

//
// --------- LootTemplate::LootGroup ---------
//

// Adds an entry to the group (at loading stage)
void LootTemplate::LootGroup::AddEntry (LootStoreItem& item)
{
    if (item.chance != 0)
        ExplicitlyChanced.push_back(item);
    else
        EqualChanced.push_back(item);
}

// Rolls an item from the group, returns NULL if all miss their chances
LootStoreItem const * LootTemplate::LootGroup::Roll () const
{
    if (!ExplicitlyChanced.empty())          // First explicitly chanced entries are checked
    {
        float Roll = (float) rand_chance();

        for (uint32 i = 0; i < ExplicitlyChanced.size(); ++i)          // check each explicitly chanced entry in the template and modify its chance based on quality.
        {
            if (ExplicitlyChanced[i].chance >= 100.0f)
                return &ExplicitlyChanced[i];

            Roll -= ExplicitlyChanced[i].chance;
            if (Roll < 0)
                return &ExplicitlyChanced[i];
        }
    }
    if (!EqualChanced.empty())          // If nothing selected yet - an item is taken from equal-chanced part
        return &EqualChanced[irand(0, EqualChanced.size() - 1)];

    return NULL;          // Empty drop from the group
}

// True if group includes at least 1 quest drop entry
bool LootTemplate::LootGroup::HasQuestDrop () const
{
    for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
        if (i->needs_quest)
            return true;
    for (LootStoreItemList::const_iterator i = EqualChanced.begin(); i != EqualChanced.end(); ++i)
        if (i->needs_quest)
            return true;
    return false;
}

// True if group includes at least 1 quest drop entry for active quests of the player
bool LootTemplate::LootGroup::HasQuestDropForPlayer (Player const * player) const
{
    for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
        if (player->HasQuestForItem(i->itemid))
            return true;
    for (LootStoreItemList::const_iterator i = EqualChanced.begin(); i != EqualChanced.end(); ++i)
        if (player->HasQuestForItem(i->itemid))
            return true;
    return false;
}

void LootTemplate::LootGroup::CopyConditions (ConditionList /*conditions*/)
{
    for (LootStoreItemList::iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
    {
        i->conditions.clear();
    }
    for (LootStoreItemList::iterator i = EqualChanced.begin(); i != EqualChanced.end(); ++i)
    {
        i->conditions.clear();
    }
}

// Rolls an item from the group (if any takes its chance) and adds the item to the loot
void LootTemplate::LootGroup::Process (Loot& loot, uint16 lootMode) const
{
    // build up list of possible drops
    LootStoreItemList EqualPossibleDrops = EqualChanced;
    LootStoreItemList ExplicitPossibleDrops = ExplicitlyChanced;

    uint8 uiAttemptCount = 0;
    const uint8 uiMaxAttempts = ExplicitlyChanced.size() + EqualChanced.size();

    while (!ExplicitPossibleDrops.empty() || !EqualPossibleDrops.empty())
    {
        if (uiAttemptCount == uiMaxAttempts)          // already tried rolling too many times, just abort
            return;

        LootStoreItem *item = NULL;

        // begin rolling (normally called via Roll())
        LootStoreItemList::iterator itr;
        uint8 itemSource = 0;
        if (!ExplicitPossibleDrops.empty())          // First explicitly chanced entries are checked
        {
            itemSource = 1;
            float Roll = (float) rand_chance();
            // check each explicitly chanced entry in the template and modify its chance based on quality
            for (itr = ExplicitPossibleDrops.begin(); itr != ExplicitPossibleDrops.end(); itr = ExplicitPossibleDrops.erase(itr))
            {
                if (itr->chance >= 100.0f)
                {
                    item = &*itr;
                    break;
                }

                Roll -= itr->chance;
                if (Roll < 0)
                {
                    item = &*itr;
                    break;
                }
            }
        }
        if (item == NULL && !EqualPossibleDrops.empty())          // If nothing selected yet - an item is taken from equal-chanced part
        {
            itemSource = 2;
            itr = EqualPossibleDrops.begin();
            std::advance(itr, irand(0, EqualPossibleDrops.size() - 1));
            item = &*itr;
        }
        // finish rolling

        ++uiAttemptCount;

        if (item != NULL && item->lootmode & lootMode)          // only add this item if roll succeeds and the mode matches
        {
            bool duplicate = false;
            if (ItemPrototype const *_proto = sItemStorage.LookupEntry<ItemPrototype>(item->itemid))
            {
                uint8 _item_counter = 0;
                for (LootItemList::const_iterator _item = loot.items.begin(); _item != loot.items.end(); ++_item)
                    if (_item->itemid == item->itemid)          // search through the items that have already dropped
                    {
                        ++_item_counter;
                        if (_proto->InventoryType == 0 && _item_counter == 3)          // Non-equippable items are limited to 3 drops
                            duplicate = true;
                        else if (_proto->InventoryType != 0 && _item_counter == 1)          // Equippable item are limited to 1 drop
                            duplicate = true;
                    }
            }
            if (duplicate)          // if item->itemid is a duplicate, remove it
                switch (itemSource)
                {
                case 1:          // item came from ExplicitPossibleDrops
                    ExplicitPossibleDrops.erase(itr);
                    break;
                case 2:          // item came from EqualPossibleDrops
                    EqualPossibleDrops.erase(itr);
                    break;
                }
            else          // otherwise, add the item and exit the function
            {
                loot.AddItem(*item);
                return;
            }
        }
    }
}

// Overall chance for the group without equal chanced items
float LootTemplate::LootGroup::RawTotalChance () const
{
    float result = 0;

    for (LootStoreItemList::const_iterator i = ExplicitlyChanced.begin(); i != ExplicitlyChanced.end(); ++i)
        if (!i->needs_quest)
            result += i->chance;

    return result;
}

// Overall chance for the group
float LootTemplate::LootGroup::TotalChance () const
{
    float result = RawTotalChance();

    if (!EqualChanced.empty() && result < 100.0f)
        return 100.0f;

    return result;
}

void LootTemplate::LootGroup::Verify (LootStore const& lootstore, uint32 id, uint8 group_id) const
{
    float chance = RawTotalChance();
    if (chance > 101.0f)          // TODO: replace with 100% when DBs will be ready
    {
        sLog->outErrorDb(""Table '%s' entry %u group %d has total chance > 100%% (%f)"", lootstore.GetName(), id, group_id, chance);
    }

    if (chance >= 100.0f && !EqualChanced.empty())
    {
        sLog->outErrorDb(""Table '%s' entry %u group %d has items with chance=0%% but group total chance >= 100%% (%f)"", lootstore.GetName(), id, group_id, chance);
    }
}

void LootTemplate::LootGroup::CheckLootRefs (LootTemplateMap const& /*store*/, LootIdSet* ref_set) const
{
    for (LootStoreItemList::const_iterator ieItr = ExplicitlyChanced.begin(); ieItr != ExplicitlyChanced.end(); ++ieItr)
    {
        if (ieItr->mincountOrRef < 0)
        {
            if (!LootTemplates_Reference.GetLootFor(-ieItr->mincountOrRef))
                LootTemplates_Reference.ReportNotExistedId(-ieItr->mincountOrRef);
            else if (ref_set)
                ref_set->erase(-ieItr->mincountOrRef);
        }
    }

    for (LootStoreItemList::const_iterator ieItr = EqualChanced.begin(); ieItr != EqualChanced.end(); ++ieItr)
    {
        if (ieItr->mincountOrRef < 0)
        {
            if (!LootTemplates_Reference.GetLootFor(-ieItr->mincountOrRef))
                LootTemplates_Reference.ReportNotExistedId(-ieItr->mincountOrRef);
            else if (ref_set)
                ref_set->erase(-ieItr->mincountOrRef);
        }
    }
}

//
// --------- LootTemplate ---------
//

// Adds an entry to the group (at loading stage)
void LootTemplate::AddEntry (LootStoreItem& item)
{
    if (item.group > 0 && item.mincountOrRef > 0)          // Group
    {
        if (item.group >= Groups.size())
            Groups.resize(item.group);          // Adds new group the the loot template if needed
        Groups[item.group - 1].AddEntry(item);          // Adds new entry to the group
    }
    else
        // Non-grouped entries and references are stored together
        Entries.push_back(item);
}

void LootTemplate::CopyConditions (ConditionList conditions)
{
    for (LootStoreItemList::iterator i = Entries.begin(); i != Entries.end(); ++i)
        i->conditions.clear();

    for (LootGroups::iterator i = Groups.begin(); i != Groups.end(); ++i)
        i->CopyConditions(conditions);
}

// Rolls for every item in the template and adds the rolled items the the loot
void LootTemplate::Process (Loot& loot, bool rate, uint16 lootMode, uint8 groupId) const
{
    if (groupId)          // Group reference uses own processing of the group
    {
        if (groupId > Groups.size())
            return;          // Error message already printed at loading stage

        Groups[groupId - 1].Process(loot, lootMode);
        return;
    }

    // Rolling non-grouped items
    for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
    {
        if (i->lootmode & ~lootMode)          // Do not add if mode mismatch
            continue;

        if (!i->Roll(rate))
            continue;          // Bad luck for the entry

        if (ItemPrototype const *_proto = sItemStorage.LookupEntry<ItemPrototype>(i->itemid))
        {
            uint8 _item_counter = 0;
            LootItemList::const_iterator _item = loot.items.begin();
            for (; _item != loot.items.end(); ++_item)
                if (_item->itemid == i->itemid)          // search through the items that have already dropped
                {
                    ++_item_counter;
                    if (_proto->InventoryType == 0 && _item_counter == 3)          // Non-equippable items are limited to 3 drops
                        continue;
                    else if (_proto->InventoryType != 0 && _item_counter == 1)          // Equippable item are limited to 1 drop
                        continue;
                }
            if (_item != loot.items.end())
                continue;
        }

        if (i->mincountOrRef < 0)          // References processing
        {
            LootTemplate const* Referenced = LootTemplates_Reference.GetLootFor(-i->mincountOrRef);

            if (!Referenced)
                continue;          // Error message already printed at loading stage

            uint32 maxcount = uint32(float(i->maxcount) * sWorld->getRate(RATE_DROP_ITEM_REFERENCED_AMOUNT));
            for (uint32 loop = 0; loop < maxcount; ++loop)          // Ref multiplicator
                Referenced->Process(loot, rate, lootMode, i->group);
        }
        else
            // Plain entries (not a reference, not grouped)
            loot.AddItem(*i);          // Chance is already checked, just add
    }

    // Now processing groups
    for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
        i->Process(loot, lootMode);
}

// True if template includes at least 1 quest drop entry
bool LootTemplate::HasQuestDrop (LootTemplateMap const& store, uint8 groupId) const
{
    if (groupId)          // Group reference
    {
        if (groupId > Groups.size())
            return false;          // Error message [should be] already printed at loading stage
        return Groups[groupId - 1].HasQuestDrop();
    }

    for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
    {
        if (i->mincountOrRef < 0)          // References
        {
            LootTemplateMap::const_iterator Referenced = store.find(-i->mincountOrRef);
            if (Referenced == store.end())
                continue;          // Error message [should be] already printed at loading stage
            if (Referenced->second->HasQuestDrop(store, i->group))
                return true;
        }
        else if (i->needs_quest)
            return true;          // quest drop found
    }

    // Now processing groups
    for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
        if (i->HasQuestDrop())
            return true;

    return false;
}

// True if template includes at least 1 quest drop for an active quest of the player
bool LootTemplate::HasQuestDropForPlayer (LootTemplateMap const& store, Player const* player, uint8 groupId) const
{
    if (groupId)          // Group reference
    {
        if (groupId > Groups.size())
            return false;          // Error message already printed at loading stage
        return Groups[groupId - 1].HasQuestDropForPlayer(player);
    }

    // Checking non-grouped entries
    for (LootStoreItemList::const_iterator i = Entries.begin(); i != Entries.end(); ++i)
    {
        if (i->mincountOrRef < 0)          // References processing
        {
            LootTemplateMap::const_iterator Referenced = store.find(-i->mincountOrRef);
            if (Referenced == store.end())
                continue;          // Error message already printed at loading stage
            if (Referenced->second->HasQuestDropForPlayer(store, player, i->group))
                return true;
        }
        else if (player->HasQuestForItem(i->itemid))
            return true;          // active quest drop found
    }

    // Now checking groups
    for (LootGroups::const_iterator i = Groups.begin(); i != Groups.end(); ++i)
        if (i->HasQuestDropForPlayer(player))
            return true;

    return false;
}

// Checks integrity of the template
void LootTemplate::Verify (LootStore const& lootstore, uint32 id) const
{
    // Checking group chances
    for (uint32 i = 0; i < Groups.size(); ++i)
        Groups[i].Verify(lootstore, id, i + 1);

    // TODO: References validity checks
}

void LootTemplate::CheckLootRefs (LootTemplateMap const& store, LootIdSet* ref_set) const
{
    for (LootStoreItemList::const_iterator ieItr = Entries.begin(); ieItr != Entries.end(); ++ieItr)
    {
        if (ieItr->mincountOrRef < 0)
        {
            if (!LootTemplates_Reference.GetLootFor(-ieItr->mincountOrRef))
                LootTemplates_Reference.ReportNotExistedId(-ieItr->mincountOrRef);
            else if (ref_set)
                ref_set->erase(-ieItr->mincountOrRef);
        }
    }

    for (LootGroups::const_iterator grItr = Groups.begin(); grItr != Groups.end(); ++grItr)
        grItr->CheckLootRefs(store, ref_set);
}
bool LootTemplate::addConditionItem (Condition* cond)
{
    if (!cond || !cond->isLoaded())          //should never happen, checked at loading
    {
        sLog->outError(""LootTemplate::addConditionItem: condition is null"");
        return false;
    }
    if (!Entries.empty())
    {
        for (LootStoreItemList::iterator i = Entries.begin(); i != Entries.end(); ++i)
        {
            if (i->itemid == cond->mSourceEntry)
            {
                i->conditions.push_back(cond);
                return true;
            }
        }
    }
    if (!Groups.empty())
    {
        for (LootGroups::iterator groupItr = Groups.begin(); groupItr != Groups.end(); ++groupItr)
        {
            LootStoreItemList* itemList = (*groupItr).GetExplicitlyChancedItemList();
            if (!itemList->empty())
            {
                for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i)
                {
                    if ((*i).itemid == cond->mSourceEntry)
                    {
                        (*i).conditions.push_back(cond);
                        return true;
                    }
                }
            }
            itemList = (*groupItr).GetEqualChancedItemList();
            if (!itemList->empty())
            {
                for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i)
                {
                    if ((*i).itemid == cond->mSourceEntry)
                    {
                        (*i).conditions.push_back(cond);
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

bool LootTemplate::isReference (uint32 id)
{
    for (LootStoreItemList::const_iterator ieItr = Entries.begin(); ieItr != Entries.end(); ++ieItr)
    {
        if (ieItr->itemid == id && ieItr->mincountOrRef < 0)
            return true;
    }
    return false;          //not found or not reference
}

void LoadLootTemplates_Creature ()
{
    sLog->outString(""Loading creature loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set, ids_setUsed;
    uint32 count = LootTemplates_Creature.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sCreatureStorage.MaxEntry; ++i)
    {
        if (CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(i))
        {
            if (uint32 lootid = cInfo->lootid)
            {
                if (ids_set.find(lootid) == ids_set.end())
                LootTemplates_Creature.ReportNotExistedId(lootid);
                else
                ids_setUsed.insert(lootid);
            }
        }
    }
    for (LootIdSet::const_iterator itr = ids_setUsed.begin(); itr != ids_setUsed.end(); ++itr)
    ids_set.erase(*itr);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Creature.ReportUnusedIds(ids_set);

    if (count)
    sLog->outString("">> Loaded %u creature loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
    sLog->outErrorDb("">> Loaded 0 creature loot templates. DB table `creature_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Disenchant ()
{
    sLog->outString(""Loading disenchanting loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set, ids_setUsed;
    uint32 count = LootTemplates_Disenchant.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sItemStorage.MaxEntry; ++i)
    {
        if (ItemPrototype const *proto = sItemStorage.LookupEntry<ItemPrototype>(i))
        {
            if (uint32 lootid = proto->DisenchantID)
            {
                if (ids_set.find(lootid) == ids_set.end())
                LootTemplates_Disenchant.ReportNotExistedId(lootid);
                else
                ids_setUsed.insert(lootid);
            }
        }
    }
    for (LootIdSet::const_iterator itr = ids_setUsed.begin(); itr != ids_setUsed.end(); ++itr)
    ids_set.erase(*itr);
    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Disenchant.ReportUnusedIds(ids_set);

    if (count)
    sLog->outString("">> Loaded %u disenchanting loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
    sLog->outErrorDb("">> Loaded 0 disenchanting loot templates. DB table `disenchant_loot_template` is empty"");
    sLog->outString();
}

void LoadLootTemplates_Fishing ()
{
    sLog->outString(""Loading fishing loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    uint32 count = LootTemplates_Fishing.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sAreaStore.GetNumRows(); ++i)
        if (AreaTableEntry const* areaEntry = sAreaStore.LookupEntry(i))
            if (ids_set.find(areaEntry->ID) != ids_set.end())
                ids_set.erase(areaEntry->ID);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Fishing.ReportUnusedIds(ids_set);

    if (count)
        sLog->outString("">> Loaded %u fishing loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
        sLog->outErrorDb("">> Loaded 0 fishing loot templates. DB table `fishing_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Gameobject ()
{
    sLog->outString(""Loading gameobject loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set, ids_setUsed;
    uint32 count = LootTemplates_Gameobject.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sGOStorage.MaxEntry; ++i)
    {
        if (GameObjectInfo const* gInfo = sGOStorage.LookupEntry<GameObjectInfo>(i))
        {
            if (uint32 lootid = gInfo->GetLootId())
            {
                if (sObjectMgr->IsGoOfSpecificEntrySpawned(gInfo->id) && ids_set.find(lootid) == ids_set.end())
                LootTemplates_Gameobject.ReportNotExistedId(lootid);
                else
                ids_setUsed.insert(lootid);
            }
        }
    }
    for (LootIdSet::const_iterator itr = ids_setUsed.begin(); itr != ids_setUsed.end(); ++itr)
    ids_set.erase(*itr);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Gameobject.ReportUnusedIds(ids_set);

    if (count)
    sLog->outString("">> Loaded %u gameobject loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
    sLog->outErrorDb("">> Loaded 0 gameobject loot templates. DB table `gameobject_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Item ()
{
    sLog->outString(""Loading item loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    uint32 count = LootTemplates_Item.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sItemStorage.MaxEntry; ++i)
        if (ItemPrototype const *proto = sItemStorage.LookupEntry<ItemPrototype>(i))
            if (ids_set.find(proto->ItemId) != ids_set.end() && proto->Flags & ITEM_PROTO_FLAG_OPENABLE)
                ids_set.erase(proto->ItemId);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Item.ReportUnusedIds(ids_set);

    if (count)
        sLog->outString("">> Loaded %u prospecting loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
        sLog->outErrorDb("">> Loaded 0 prospecting loot templates. DB table `item_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Milling ()
{
    sLog->outString(""Loading milling loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    uint32 count = LootTemplates_Milling.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sItemStorage.MaxEntry; ++i)
    {
        ItemPrototype const *proto = sItemStorage.LookupEntry<ItemPrototype>(i);
        if (!proto)
            continue;

        if (!(proto->Flags & ITEM_PROTO_FLAG_MILLABLE))
            continue;

        if (ids_set.find(proto->ItemId) != ids_set.end())
            ids_set.erase(proto->ItemId);
    }

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Milling.ReportUnusedIds(ids_set);

    if (count)
        sLog->outString("">> Loaded %u milling loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
        sLog->outErrorDb("">> Loaded 0 milling loot templates. DB table `milling_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Pickpocketing ()
{
    sLog->outString(""Loading pickpocketing loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set, ids_setUsed;
    uint32 count = LootTemplates_Pickpocketing.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sCreatureStorage.MaxEntry; ++i)
    {
        if (CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(i))
        {
            if (uint32 lootid = cInfo->pickpocketLootId)
            {
                if (ids_set.find(lootid) == ids_set.end())
                LootTemplates_Pickpocketing.ReportNotExistedId(lootid);
                else
                ids_setUsed.insert(lootid);
            }
        }
    }
    for (LootIdSet::const_iterator itr = ids_setUsed.begin(); itr != ids_setUsed.end(); ++itr)
    ids_set.erase(*itr);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Pickpocketing.ReportUnusedIds(ids_set);

    if (count)
    sLog->outString("">> Loaded %u pickpocketing loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
    sLog->outErrorDb("">> Loaded 0 pickpocketing loot templates. DB table `pickpocketing_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Prospecting ()
{
    sLog->outString(""Loading prospecting loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    uint32 count = LootTemplates_Prospecting.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sItemStorage.MaxEntry; ++i)
    {
        ItemPrototype const *proto = sItemStorage.LookupEntry<ItemPrototype>(i);
        if (!proto)
            continue;

        if (!(proto->Flags & ITEM_PROTO_FLAG_PROSPECTABLE))
            continue;

        if (ids_set.find(proto->ItemId) != ids_set.end())
            ids_set.erase(proto->ItemId);
    }

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Prospecting.ReportUnusedIds(ids_set);

    if (count)
        sLog->outString("">> Loaded %u prospecting loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
        sLog->outErrorDb("">> Loaded 0 prospecting loot templates. DB table `prospecting_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Mail ()
{
    sLog->outString(""Loading mail loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    uint32 count = LootTemplates_Mail.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sMailTemplateStore.GetNumRows(); ++i)
        if (sMailTemplateStore.LookupEntry(i))
            if (ids_set.find(i) != ids_set.end())
                ids_set.erase(i);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Mail.ReportUnusedIds(ids_set);

    if (count)
        sLog->outString("">> Loaded %u mail loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
        sLog->outErrorDb("">> Loaded 0 mail loot templates. DB table `mail_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Skinning ()
{
    sLog->outString(""Loading skinning loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set, ids_setUsed;
    uint32 count = LootTemplates_Skinning.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 i = 1; i < sCreatureStorage.MaxEntry; ++i)
    {
        if (CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(i))
        {
            if (uint32 lootid = cInfo->SkinLootId)
            {
                if (ids_set.find(lootid) == ids_set.end())
                LootTemplates_Skinning.ReportNotExistedId(lootid);
                else
                ids_setUsed.insert(lootid);
            }
        }
    }
    for (LootIdSet::const_iterator itr = ids_setUsed.begin(); itr != ids_setUsed.end(); ++itr)
    ids_set.erase(*itr);

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Skinning.ReportUnusedIds(ids_set);

    if (count)
    sLog->outString("">> Loaded %u skinning loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
    sLog->outErrorDb("">> Loaded 0 skinning loot templates. DB table `skinning_loot_template` is empty"");

    sLog->outString();
}

void LoadLootTemplates_Spell ()
{
    sLog->outString(""Loading spell loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    uint32 count = LootTemplates_Spell.LoadAndCollectLootIds(ids_set);

    // remove real entries and check existence loot
    for (uint32 spell_id = 1; spell_id < sSpellStore.GetNumRows(); ++spell_id)
    {
        SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell_id);
        if (!spellInfo)
            continue;

        // possible cases
        if (!IsLootCraftingSpell(spellInfo))
            continue;

        if (ids_set.find(spell_id) == ids_set.end())
        {
            // not report about not trainable spells (optionally supported by DB)
            // ignore 61756 (Northrend Inscription Research (FAST QA VERSION) for example
            if (!(spellInfo->Attributes & SPELL_ATTR0_NOT_SHAPESHIFT) || (spellInfo->Attributes & SPELL_ATTR0_TRADESPELL))
            {
                LootTemplates_Spell.ReportNotExistedId(spell_id);
            }
        }
        else
            ids_set.erase(spell_id);
    }

    // output error for any still listed (not referenced from appropriate table) ids
    LootTemplates_Spell.ReportUnusedIds(ids_set);

    if (count)
        sLog->outString("">> Loaded %u spell loot templates in %u ms"", count, GetMSTimeDiffToNow(oldMSTime));
    else
        sLog->outErrorDb("">> Loaded 0 spell loot templates. DB table `spell_loot_template` is empty"");
    sLog->outString();
}

void LoadLootTemplates_Reference ()
{
    sLog->outString(""Loading reference loot templates..."");

    uint32 oldMSTime = getMSTime();

    LootIdSet ids_set;
    LootTemplates_Reference.LoadAndCollectLootIds(ids_set);

    // check references and remove used
    LootTemplates_Creature.CheckLootRefs(&ids_set);
    LootTemplates_Fishing.CheckLootRefs(&ids_set);
    LootTemplates_Gameobject.CheckLootRefs(&ids_set);
    LootTemplates_Item.CheckLootRefs(&ids_set);
    LootTemplates_Milling.CheckLootRefs(&ids_set);
    LootTemplates_Pickpocketing.CheckLootRefs(&ids_set);
    LootTemplates_Skinning.CheckLootRefs(&ids_set);
    LootTemplates_Disenchant.CheckLootRefs(&ids_set);
    LootTemplates_Prospecting.CheckLootRefs(&ids_set);
    LootTemplates_Mail.CheckLootRefs(&ids_set);
    LootTemplates_Reference.CheckLootRefs(&ids_set);

    // output error for any still listed ids (not referenced from any loot table)
    LootTemplates_Reference.ReportUnusedIds(ids_set);

    sLog->outString("">> Loaded refence loot templates in %u ms"", GetMSTimeDiffToNow(oldMSTime));
    sLog->outString();
}
",16193,True,3035.4762762763403,median
"/*

Chien 2D Mapa

Copyright 2007-2010, Paulo Vinicius Wolski Radtke (pvwradtke@gmail.com)

   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.
*/

/**

	Data		Programador	Alteração
	=====================================================
	13/08/2010	Paulo VW Radtke	Funções para mudar uma camada do mapa e para pegar a camada de marcas.


**/


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#if	defined(linux)
	#include <SDL/SDL_endian.h>
#else
	#include <SDL_endian.h>
#endif

#include <c2d2/chien2d2.h>
#include <c2d2/chien2d2mapa.h>

char cabecalhos[6][5] ={ ""FORM"", ""FMAP"", ""MPHD"", ""ANDT"", ""BODY"", ""LYR?""};

// indica se a Chien2D2 Mappy já foi inicializada. Por default, não foi ainda.
bool m_inicializado = false;

// O vetor com os mapas
C2D2M_Mapa mapas[C2D2M_MAX_MAPAS];
// Indica se o sistema está em shutdown ou não
bool m_shutdown = false;

// Funções exclusivas para desenvolvimento interno. Não use no seu programa!!

// Função para zerar os dados da Chien2D 2
void m_reset();


// Funções da C2D2 Mapa

// Função para zerar os dados da Chien2D 2
//
// Data: 29/03/2007

void m_reset()
{
	// Zera os mapas
	for(int i=0;i<C2D2M_MAX_MAPAS; i++)
	{
		// Apaga o apelido
		strcpy(mapas[i].apelido, """");
		// Zera o número de usuários
		mapas[i].usuarios = 0;
		// Zera o ponteiro das camadas
		for(int j=0;j<C2D2M_MAX_CAMADAS;j++)
			mapas[i].camadas[j] = 0;
		mapas[i].idSpriteset = 0;
		mapas[i].inicializado = false;
		mapas[i].camadaMarcas=-1;
	}
}

// Função para iniciar a Chien2D 2 Mapa
//
// Data: 27/07/2007

bool C2D2M_Inicia()
{
    if(m_inicializado)
        return false; 
	else
		m_reset();

	// Indica que foi iniciado e pula fora
    m_inicializado=true;
    return true;
}


// Função que encerra a Chien2D 2
//
// Data: 29/03/2007

void C2D2M_Encerra()
{
    // Testa por via das dúvidas para não ter problemas
    if(!m_inicializado)
        return;
    // Indica que está encerrando
    m_shutdown = true;
        
    printf(""Apagando os mapas do sistema.\\n"");

    // Apaga os mapas
    for(int i=0;i<C2D2M_MAX_MAPAS;i++)
        C2D2M_RemoveMapa(i+1);

    m_inicializado=false;
}

// função para carregar um sprite set na memória
//
// Data: 13/04/2007
//
unsigned int C2D2M_CarregaMapaMappy(const char *arquivo_mapa, const char *arquivo_spriteset)
{
    // Verifica se o mapa não existe já
    unsigned int idx = C2D2M_ProcuraMapa(arquivo_mapa);
    // Se já existe um sprite com o nome do arquivo, retorna o índice associado
    if(idx != 0)
    {
		mapas[idx-1].usuarios=mapas[idx-1].usuarios+1;
        return idx;
    }
        
    // Se não existe, procura o primeiro índice vago (idx ainda é igual a 0)
    for(int i=0;i<C2D2M_MAX_MAPAS;i++)
        // O spriteset é vago (não tem imagem associada?
        if(!mapas[i].inicializado)
        {
            idx=i+1;
            break;
        }
 
    // Testa se ainda tem espaço na lista
    //
    // ATENÇÃO: não ter espaço na memória não é relacionado a este teste. Apenas
    // testa-se aqui se existe um índice vago na lista. Se não existe, idx==0
    if(idx==0)
        // Retorna um índice inválido para indicar que a função falhou
        return 0;
    
    // Se chegou até aqui, idx contém o identificador correto 
    // Calcula a posição no array (sem incrementar 1)
    idx-=1;    
	// Indica o caminho do arquivo no apelido
    strcpy(mapas[idx].apelido,arquivo_mapa);

	//////////////////////////////////////////////////

    FILE *mapa = fopen(arquivo_mapa, ""rb"");
	// Se falhou abrir o arquivo, deve retornar o erro
    if(mapa == 0)
	{
		C2D2M_RemoveMapa(idx+1);
        return 0;
	}
    // pega o tamanho do arquivo
	fseek(mapa, 0, SEEK_END);
    int tamanho = ftell(mapa);
    fseek(mapa, 0, SEEK_SET);
    // Aloca memória para o arquivo inteiro
    char *buffer = (char *)malloc(tamanho*sizeof(char));
    // Lê os dados
	fread(buffer, sizeof(char), tamanho, mapa);
    // Fecha o arquivo
      fclose(mapa);
    // Pega o ""suposto"" cabeçalho do arquivo
    CabecalhoArquivo *cabArq = (CabecalhoArquivo*)buffer;
    // Verifica se o cabecalho é certo
    if(C2D2M_VerificaCabecalhoArquivo(cabArq))
    {
        // Recupera o tamanho do arquivo (está em BIG ENDIAN)
        int tamanho = cabArq->tamanho;
        if(SDL_BYTEORDER == SDL_LIL_ENDIAN)
            tamanho = SDL_Swap32(tamanho);
        // O tamanho total soma 8
        tamanho+=8;
        // Índice dentro do buffer lido, já pulando o header de 12 bytes
        int indice=12;        
        // Indica se o arquivo é armazenado em little endian (recupera do MPHD)
        bool arquivoLilEndian=false;
        // Indica se o sistema é lil endian (usado com a variável em arquivo)
        bool sistemaLilEndian = false;
        if(SDL_BYTEORDER == SDL_LIL_ENDIAN)
            sistemaLilEndian=true;
        // Processa os chunks do arquivo enquanto o índice estiver dentro do arquivo
        while(indice < tamanho)
        {
            // pega o próximo chunk
            CabecalhoBloco *bloco = (CabecalhoBloco *)&(buffer[indice]);
            // Faz o indice apontar para os dados do bloco (pula 8 bytes)
            indice += 8;
            // Pega o tamanho do bloco (está no formato intel)
            int tamBloco = bloco->tamanho;
            if(SDL_BYTEORDER == SDL_LIL_ENDIAN)
                tamBloco = SDL_Swap32(tamBloco);
            //    Aqui extraímos as informações dos blocos. Nos interessam apenas
            // o header do arquivo (MPHD), o cenário (BODY), os layers (LYR""X"")
            // e as animações (ANDT)
            switch(C2D2M_TipoBloco(bloco))
            {
                case CABECALHO_MPHD:
                {
                    // Acessa o header
                    MPHD *mphd = (MPHD *)&(buffer[indice]);
                    // O arquivo é codificado em Little Endian?
                    if(mphd->lsb)
                        arquivoLilEndian=true;
                    // Extra as informações relevantes
                    mapas[idx].altura = mphd->mapheight;
                    mapas[idx].largura = mphd->mapwidth;
                    mapas[idx].dimensaoBlocoH = mphd->blockwidth;
                    mapas[idx].dimensaoBlocoV = mphd->blockheight;
                    // Se o sistema e arquivo não baterem
                    if(arquivoLilEndian != sistemaLilEndian)
                    {
                        mapas[idx].altura = SDL_Swap16(mapas[idx].altura);
                        mapas[idx].largura = SDL_Swap16(mapas[idx].largura);
                        mapas[idx].dimensaoBlocoH = SDL_Swap16(mapas[idx].dimensaoBlocoH);
                        mapas[idx].dimensaoBlocoV = SDL_Swap16(mapas[idx].dimensaoBlocoV);
                    }
                    // Calcula a largura do mapa em pixels
                    mapas[idx].larguraPixel = mapas[idx].largura*mapas[idx].dimensaoBlocoH;
                    mapas[idx].alturaPixel = mapas[idx].altura*mapas[idx].dimensaoBlocoV;
                    break;
                }
                // Bloco dos dados da camada principal (0)
                case CABECALHO_BODY:
                {
                    // Aloca a memória do layer principal
					mapas[idx].camadas[0] = (short int*)malloc(mapas[idx].altura*mapas[idx].largura*sizeof(short int));
                    // Copia os dados do buffer para a camada
                    memcpy(mapas[idx].camadas[0], (short int*)&(buffer[indice]), 
                            mapas[idx].largura*mapas[idx].altura*sizeof(short int));
                    if(arquivoLilEndian != sistemaLilEndian)
                        for(int i=0;i<mapas[idx].altura*mapas[idx].largura;i++)
                           mapas[idx].camadas[0][i]=SDL_Swap16(mapas[idx].camadas[0][i]); 
                    break;
                }
                // Um dos layers associados
                case CABECALHO_LYR:
                {
                    // Determina a camada
                    int camada = bloco->tipo[3]-'0';
                    // Aloca a memória do layer principal
                    mapas[idx].camadas[camada] = (short int*)malloc(mapas[idx].altura*mapas[idx].largura*sizeof(short int));
                    // Copia os dados do buffer para a camada
                    memcpy(mapas[idx].camadas[camada], (short int*)&(buffer[indice]), 
                            mapas[idx].altura*mapas[idx].largura*sizeof(short int));
                    if(arquivoLilEndian != sistemaLilEndian)
                        for(int i=0;i<mapas[idx].altura*mapas[idx].largura;i++)
                           mapas[idx].camadas[camada][i]=SDL_Swap16(mapas[idx].camadas[camada][i]); 
                    break;
                }
                // Animações
                case CABECALHO_ANDT:
                {
                    // Procura as estruturas ANISTR (tem que ter pelo menos uma)
                    int numAniStr=0;
                    while(true)
                    {
                        // Pega a estrutura (a zero é vazia)
                        numAniStr++;
						memcpy(&(mapas[idx].estrutAnimacao[numAniStr]), 
                            (ANISTR*)&(buffer[indice+tamBloco-sizeof(ANISTR)*numAniStr]),
                            sizeof(ANISTR));
                        // Se a animação é do tipo AN_END, chegou ao fim
                        if(mapas[idx].estrutAnimacao[numAniStr].antype == AN_END)
                            break;
                    }
                    // Extrai as sequências de animação: tamanho do bloco- ANISTR lidas
                    int numAnimSeq=(tamBloco-sizeof(ANISTR)*numAniStr)/sizeof(long int);
                    memcpy(mapas[idx].seqAnimacao, (long int*)&(buffer[indice]),
                        sizeof(long int)*numAnimSeq);
                    // Ajusta os dados com mais de um byte
                    if(arquivoLilEndian != sistemaLilEndian)
                    {
                        for(int i=0;i<numAniStr;i++)
                        {
                           mapas[idx].estrutAnimacao[i].ancuroff = SDL_Swap32(mapas[idx].estrutAnimacao[i].ancuroff); 
                           mapas[idx].estrutAnimacao[i].anstartoff = SDL_Swap32(mapas[idx].estrutAnimacao[i].anstartoff); 
                           mapas[idx].estrutAnimacao[i].anendoff = SDL_Swap32(mapas[idx].estrutAnimacao[i].anendoff);                                                      
                        }
                        for(int i=0;i<numAnimSeq;i++)
                            mapas[idx].seqAnimacao[i] = SDL_Swap32(mapas[idx].seqAnimacao[i]);
                    }
                    break;                    
                }
                
                // Ignora o bloco e passa para o próximo
                default:
                    break;
            }
            // Atualiza a posição do índice
            indice += tamBloco;
        }
    }
    // Apaga o buffer
    free(buffer);

	//////////////////////////////////////////////////

	// Tenta carregar o spriteset
	mapas[idx].idSpriteset = C2D2_CarregaSpriteSet(arquivo_spriteset, mapas[idx].dimensaoBlocoH, mapas[idx].dimensaoBlocoV);
	// Se não conseguiu, apaga tudo
	if(	mapas[idx].idSpriteset == 0)
	{
		C2D2M_RemoveMapa(idx+1);
		return 0;
	}
	// Daqui pra frente é ladeira ...

	// Zera as velocidades do mapa
	memset(mapas[idx].vCamadas, 0, C2D2M_MAX_CAMADAS*sizeof(int));
	// Indica que tem um usuário
    mapas[idx].usuarios = 1;
	// Coordenadas iniciais do mapa
	mapas[idx].x=0;
	mapas[idx].y=0;
	// Camada de marcadores default: -1
	mapas[idx].camadaMarcas = -1;
	// Indica que não está procurando um mapa
	mapas[idx].buscaProximo = false;
	// Coloca a velocidade default como 0 para mapas topview
	mapas[idx].gravidade = 0;
	// Coloca a velocidade de queda máxima em 0
	mapas[idx].maxgravidade = 0;
	// Indica que inicializou
	mapas[idx].inicializado = true;
    // idx+1 indica o identificador. Retorna e encerra (ufa!)
    return idx+1;
}


// Remove um mapa da memória
//
// Data: 28/07/2007
//
void C2D2M_RemoveMapa(unsigned int id)
{
    // O identificador é válido?
    if(id >= C2D2M_MAX_MAPAS || id == 0)
        return;
    // Só apaga se o número de usuários for um ou se estiver em shutdown
    if(mapas[id-1].usuarios > 1 && !m_shutdown)
    {
        mapas[id-1].usuarios -= 1;
        return;
    }
    // Se cair aqui, é porquê não tem mais usuários
    mapas[id-1].usuarios = 0;
    // Tem uma surface SDL associada?
	if(mapas[id-1].idSpriteset != 0)
	{
		C2D2_RemoveSpriteSet(mapas[id-1].idSpriteset);
		mapas[id-1].idSpriteset = 0;
	}
    for(int i=0;i<C2D2M_MAX_CAMADAS;i++)
		if(mapas[id-1].camadas[i] != 0)
		{
            free(mapas[id-1].camadas[i]);
			mapas[id-1].camadas[i] = 0;
		}
	strcpy(mapas[id-1].apelido, """");
	// Enfim, indica que não está inicializado
	mapas[id-1].inicializado = false;
}


// Procura um mapa pelo nome do arquivo original
//
// Data: 13/04/2007
//
unsigned int C2D2M_ProcuraMapa(const char *apelido)
{
    // Índice de spriteset inválido, caso não encontre
    unsigned int idx=0;
    for(int i=0;i<C2D2M_MAX_MAPAS;i++)
        if(strcmp(mapas[i].apelido, apelido)==0)
        {
            // O índice é a posição atual + 1
            idx=i+1;
            // Encerra a busca
            break;
        }
    return idx;
}

// Função para ver as dimensões do mapa (retorna true se o mapa é válido, false caso contrário)
//
// Data: 26/01/2005
// Última atualização: 02/08/2007

bool C2D2M_DimensoesMapa(unsigned int idMapa, int *largura, int *altura)
{
	// É um índice válido?
	if(idMapa >= C2D2M_MAX_MAPAS)
		return false;
    // Se não foi inicializado, falha!
    if(!mapas[idMapa-1].inicializado)
        return false;
    // Preenche os valores
	*largura = mapas[idMapa-1].larguraPixel;
	*altura = mapas[idMapa-1].alturaPixel;
    return true;
}

// Posiciona o mapa nas coordenadas x,y indicadas
//
// Data: 16/08/2006
void C2D2M_PosicionaMapa(unsigned int idMapa, int x, int y)
{
    // O identificador é válido?
    if(idMapa >= C2D2M_MAX_MAPAS || idMapa == 0)
        return;
    // Se não foi inicializado, falha!
    if(!mapas[idMapa-1].inicializado)
        return;
	mapas[idMapa-1].x = x;
	mapas[idMapa-1].y = y;
}

// Recupera a posição do mapa
//
// Data: 16/08/2006
bool C2D2M_PosicaoXY(unsigned int idMapa, int *x, int *y)
{
    // O identificador é válido?
    if(idMapa >= C2D2M_MAX_MAPAS || idMapa == 0)
        return false;
    // Se não foi inicializado, falha!
    if(!mapas[idMapa-1].inicializado)
        return false;
	*x = mapas[idMapa-1].x;
	*y = mapas[idMapa-1].y;
	return true;
}

// Função para dar velocidade a uma camada do mapa
//
// Data: 02/08/2007

void C2D2M_VelocidadeCamadaMapa(unsigned int idMapa, int camada, int velocidade)
{
	// É um mapa válido?
	if(idMapa==0 || idMapa >= C2D2M_MAX_MAPAS)
		return;
	// É um índice válido?
	if(camada >= C2D2M_MAX_MAPAS || camada <0)
		return;
    // Se não foi inicializado, falha!
    if(!mapas[idMapa-1].inicializado)
        return;
	// A camada é válida?
	if(camada<0 || camada>=C2D2M_MAX_CAMADAS)
		return;
	mapas[idMapa-1].vCamadas[camada] = velocidade;
}

// Função para indicar a camada de marcas do mapa e o número do bloco inicial de marcas no cenário
//
// Data: 16/08/2007
//
bool C2D2M_CamadaMarcas(unsigned int idMapa, int camada, int offbloco)
{
	// É um mapa válido?
	if(idMapa==0 || idMapa >= C2D2M_MAX_MAPAS)
		return false;
	// É um índice válido?
	if(camada >= C2D2M_MAX_MAPAS)
		return false;
	// Enfim, marca a camada
	mapas[idMapa-1].camadaMarcas = camada;
	mapas[idMapa-1].offbloco = offbloco;
	// Reseta a busca de blocos, caso alguém use um dia a habilidade de mudar as camadas do mapa
	mapas[idMapa-1].buscaProximo = false;
	return true;
}


// Método para desenhar o mapa na tela a partir das coordenadas x,y do mapa
//
// Data: 26/01/2005
// Última atualização: 28/01/2005


// Função para desenhar uma camada do mapa na tela a partir das coordenadas do mapa (x,y na estrutura), dentro da janela especificada
// por xtela,ytela e as dimensões largura e altura.
//
// Data: 28/01/2005
// Última atualização: 16/08/2007

void C2D2M_DesenhaCamadaMapa(unsigned int idMapa, int camada, int xtela, int ytela, int largura, int altura)
{
	// É um índice válido?
	if(idMapa > C2D2M_MAX_MAPAS || idMapa ==0)
		return;
	if(!mapas[idMapa-1].inicializado)
        return;
    // TEsta se é um layer válido
	if(camada >= C2D2M_MAX_CAMADAS || camada <0)
        return;
	// Pega o ponteiro do mapa (mais rápido)
	C2D2M_Mapa *mapa = &mapas[idMapa-1];
    // Testa se o layer existe
	if(mapa->camadas[camada] == 0)
        return;
	
    // Só desenha o mapa se o ponto âncora for dentro do mapa e o mapa couber na tela

	if(mapa->x<0 || mapa->y<0 || mapa->x>(mapa->larguraPixel-largura) 
		|| mapa->y>( mapa->alturaPixel - altura))
        	return;
	int xmapa, ymapa;
	// Calcula o ponto de acordo com a velocidade do mapa
	if(mapa->vCamadas[camada])
	{
		xmapa=mapa->x/mapa->vCamadas[camada];
		ymapa=mapa->y/mapa->vCamadas[camada];
	}
	else
	{
		xmapa=0;
		ymapa=0;
	}
	// Pega a surface da tela
/*	SDL_Surface *tela = SDL_GetVideoSurface();
	// Prepara o retângulo de cliping
	SDL_Rect rect;
	rect.x=xtela;
	rect.y=ytela;
	rect.w=largura;
	rect.h=altura;
	// Clipa!
	SDL_SetClipRect(tela, &rect);*/
	//C2D2_LimitaAreaDesenho(xtela, ytela, largura, altura);
	// Determina as dimensões da tela em sprites (quanto vai desenhar)
	int larguraSprites = largura/mapa->dimensaoBlocoH;
	int alturaSprites = altura/mapa->dimensaoBlocoV;
	// Se as dimensões da janela não são múltiplos do tamanho do sprite, tem que desenhar um bloco a mais
	if(largura%mapa->dimensaoBlocoH)
		larguraSprites++;
	if(altura%mapa->dimensaoBlocoV)
		alturaSprites++;
    // Determina os blocos iniciais no mapa
    int blocoX = xmapa/mapa->dimensaoBlocoH;
    int blocoY = ymapa/mapa->dimensaoBlocoV;
    // DEtermina o offset em pixels DENTRO do sprite
    int offsetX = xmapa%mapa->dimensaoBlocoH;
    int offsetY = ymapa%mapa->dimensaoBlocoV;
    // Se tem offset, pode ser preciso desenhar um bloco a mais em cada direção
	// Para determinar se precisa ou não do offset, verificamos se o offset é maior que o resto da divisão pelo tamanho do bloco
    // Nota: não precisa verificar se vai ultrapassar o limite físico do mapa 
    // porque o teste da posição no mapa acima já faz isso
    if(offsetX)
        larguraSprites++;
    if(offsetY)
        alturaSprites++;
	// O sprite a ser desenhado em cada posição
	int sprite;
    // Desenha o mapa
    for(int linha=0;linha<alturaSprites;linha++)
        for(int coluna=0;coluna<larguraSprites;coluna++)
        {
            // Recupera o azulejo a desenhar
			sprite = mapa->camadas[camada][mapa->largura*(linha+blocoY)+coluna+blocoX];
            // Se o sprite for negativo, recupera o sprite na lista de animações
            if(sprite < 0)
                //    Como o valor é negativo, tem que negar antes, 
                // pegando na sequência de animação
                sprite = mapa->seqAnimacao[mapa->estrutAnimacao[-sprite].ancuroff];
            // Não desenha o sprite 0 (transparente)
            if(sprite!=0)
				C2D2_DesenhaSprite(mapa->idSpriteset, sprite-1, xtela+coluna*mapa->dimensaoBlocoH-offsetX,
					ytela+linha*mapa->dimensaoBlocoV-offsetY);
        }
	// Retira o Clip
	//SDL_SetClipRect(tela, 0);
	//C2D2_LiberaAreaDesenho();
}

// função para buscar as coordenadas da primeira ocorrência de um bloco de marca dentro de um mapa
//
// Data: 17/08/2007
bool C2D2M_PrimeiroBlocoMarca(unsigned int idMapa, int bloco, int *x, int *y)
{
	// É um índice válido?
	if(idMapa >= C2D2M_MAX_MAPAS || idMapa ==0)
		return false;
	if(!mapas[idMapa-1].inicializado)
        return false;
	// Recupera o mapa
	C2D2M_Mapa *mapa = &mapas[idMapa-1];
    // TEsta se op layer de marcas existe
	if(mapa->camadaMarcas == -1)
        return false;
	int pos;
	// Procura em cada posição até achar
	for(pos=0;pos<mapa->largura*mapa->altura;pos++)
	{
		if(mapa->camadas[mapa->camadaMarcas][pos]==bloco+mapa->offbloco)
			break;
	}
	// Se achou, pos é menor que o número total de blocos na camada
	if(pos>=mapa->largura*mapa->altura)
		return false;
	// Se chegou aqui, achou o bloco!!
	// Calcula a posição
	*x = (pos % mapa->largura) * mapa->dimensaoBlocoH + mapa->dimensaoBlocoH/2;
	*y = (pos / mapa->largura) * mapa->dimensaoBlocoV + mapa->dimensaoBlocoV/2;
	// Guarda a informação para a chamada de C2D2M_ProximoBlocoMarca
	mapa->buscaProximo = true;
	mapa->posicaoUltimo = pos;
	mapa->blocoProcurado = bloco;
	// Retorna verdade
	return true;
}

// função para buscar as coordenadas da próxima ocorrência de um bloco de marca dentro de um mapa. Usar apenas APÓS C2D2M_PrimeiroBlocoMarca.
//
// Data: 23/08/2007
bool C2D2M_ProximoBlocoMarca(unsigned int idMapa, int *x, int *y)
{
	// É um índice válido?
	if(idMapa >= C2D2M_MAX_MAPAS || idMapa ==0)
		return false;
	if(!mapas[idMapa-1].inicializado)
        return false;
	// Recupera o mapa
	C2D2M_Mapa *mapa = &mapas[idMapa-1];

	// TEsta: está procurando uma seqüência de blocos??
	if(!mapa->buscaProximo)
		return false;
	// Se chegou aqui, a camada de marcas existe e é válida. Busca
	int pos;
	// Procura em cada posição até achar
	for(pos=mapa->posicaoUltimo+1;pos<mapa->largura*mapa->altura;pos++)
	{
		if(mapa->camadas[mapa->camadaMarcas][pos]==mapa->blocoProcurado+mapa->offbloco)
			break;
	}
	// Se achou, pos é menor que o número total de blocos na camada
	if(pos>=mapa->largura*mapa->altura)
	{
		// Indica que não está mais procurando o próximo
		mapa->buscaProximo = false;
		return false;
	}
	// Se chegou aqui, achou o bloco!!
	// Calcula a posição
	*x = (pos % mapa->largura) * mapa->dimensaoBlocoH + mapa->dimensaoBlocoH/2;
	*y = (pos / mapa->largura) * mapa->dimensaoBlocoV + mapa->dimensaoBlocoV/2;
	// Guarda a informação para a próxima chamada de C2D2M_ProximoBlocoMarca
	mapa->posicaoUltimo = pos;
	// Retorna verdade
	return true;
}

// Função que indica a aceleração de gravidade do mapa, em pixels por segundo, e a velocidade máxima de gravidade para simular atrito
bool C2D2M_GravidadeMapa(unsigned int idMapa, double gravidade, double maxgravidade)
{
	// É um índice válido?
	if(idMapa >= C2D2M_MAX_MAPAS || idMapa ==0)
		return false;
	if(!mapas[idMapa-1].inicializado)
        return false;
	// Recupera o mapa
	C2D2M_Mapa *mapa = &mapas[idMapa-1];
	// Muda a gravidade
	mapa->gravidade = gravidade;
	mapa->maxgravidade = maxgravidade;
	return true;
}

// Anima os blocos animados do mapa. Atualiza os quadros, reseta e etc e tal
//
// Data: 27/01/2005
// Última atualização: 02/08/2007

void C2D2M_AnimaMapa(unsigned int id)
{
    if(id > C2D2M_MAX_MAPAS)
		return;
	// Pega o ponteiro do mapa
	C2D2M_Mapa *mapa = &mapas[id-1];
	// Testa se pode fazer a operação
    if(!mapa->inicializado)
        return;    
    // Procura as animações (0 não existe, lembrando)
    int indice = 1;
    while(mapa->estrutAnimacao[indice].antype != AN_END)
    {
        //     Verifica se não é uma animação (só Deus sabe porque isso existe)
        //     Se verdade, pula (acredite, isso faz tanto sentido pra mim como 
        // pra você, afinal, não é pra ser ANIMADO?!?
        if(mapa->estrutAnimacao[indice].antype == AN_NONE)
            continue;
        // Se a animação zera, tem que atualizar
        if((mapa->estrutAnimacao[indice].ancount-=1) == 0)
        {
            // Armazena o delay novo
            mapa->estrutAnimacao[indice].ancount = mapa->estrutAnimacao[indice].andelay;
            //    Atualiza o frame e, se estourou, volta para o início de acordo
            // com o tipo da animação
            switch(mapa->estrutAnimacao[indice].antype)
            {
                // Loop pra frente
                case AN_LOOPF:            
                {
                    if((mapa->estrutAnimacao[indice].ancuroff+=1) == mapa->estrutAnimacao[indice].anendoff)
                        mapa->estrutAnimacao[indice].ancuroff = mapa->estrutAnimacao[indice].anstartoff;
                    break;
                }
                // Loop reverso
                case AN_LOOPR:
                {
                    if((mapa->estrutAnimacao[indice].ancuroff-=1) < mapa->estrutAnimacao[indice].anstartoff)
                        mapa->estrutAnimacao[indice].ancuroff = mapa->estrutAnimacao[indice].anendoff-1;
                    break;
                }
                // Anima uma única vez (não muit oútil se não for na primeira tela)
                case AN_ONCE:            
                {
                    if(mapa->estrutAnimacao[indice].anuser)
                        break;
                    // Testa se chegou no final
                    if((mapa->estrutAnimacao[indice].ancuroff+=1) == mapa->estrutAnimacao[indice].anendoff-1)
                        mapa->estrutAnimacao[indice].anuser = true;
                    break;        
                }
                // Animação ping-pong pra frente
                case AN_PPFF:
                {
                    // Se verdade, vai de marcha-ré
                    if(mapa->estrutAnimacao[indice].anuser==0)
                    {
                        if((mapa->estrutAnimacao[indice].ancuroff-=1) < mapa->estrutAnimacao[indice].anstartoff)
                        {
                            mapa->estrutAnimacao[indice].ancuroff = mapa->estrutAnimacao[indice].anstartoff+1;
                            mapa->estrutAnimacao[indice].anuser = 1;                
                        }
                    }
                    else
                    {
                        if((mapa->estrutAnimacao[indice].ancuroff+=1) == mapa->estrutAnimacao[indice].anendoff)
                        {
                            mapa->estrutAnimacao[indice].ancuroff = mapa->estrutAnimacao[indice].anendoff-2;
                            mapa->estrutAnimacao[indice].anuser = 0;
                        }
                    }   
                    break;
                }
                // Animação ping-pong pra trás
                case AN_PPRR:
                {
                    // Se verdade, vai pra frente
                    if(mapa->estrutAnimacao[indice].anuser==0)
                    {
                        if((mapa->estrutAnimacao[indice].ancuroff+=1) == mapa->estrutAnimacao[indice].anendoff)
                        {
                            mapa->estrutAnimacao[indice].ancuroff = mapa->estrutAnimacao[indice].anendoff-2;
                            mapa->estrutAnimacao[indice].anuser = 1;
                        }
                    }
                    else
                    {
                        if((mapa->estrutAnimacao[indice].ancuroff-=1) < mapa->estrutAnimacao[indice].anstartoff)
                        {
                            mapa->estrutAnimacao[indice].ancuroff = mapa->estrutAnimacao[indice].anstartoff+1;
                            mapa->estrutAnimacao[indice].anuser = 0;                
                        }
                    }
                    break;
                }
                                   
                default:
                    break;
                
            }
        }
        // Próxima animação
        indice++;
    }
}

// Ajusta o deslocamento de um boundingbox no mapa. Recebe o mapa aonde o deslocamento
// se realiza, a posição do bounding box e o quanto deve mover no eixo x e y. O booleano
// gravidade indica se há gravidade, situação na qual deslocamentos verticais para baixo
// e cima não implicam em deslocamento no eixo x. 
//
//  Os parâmetros são o identificador do mapa (idMapa), as coordenadas do bounding box
// (x,y), as dimensões do bounding box (largura), os ponteiros para o deslocamento 
// (dx e dy) e se a gravidade está em ação.
//
// Data: XX/XX/2007
// Última atualização: 28/08/2008
//
void C2D2M_AjustaDeslocamento(unsigned int idMapa, int xorig, int yorig, 
							  int larg, int alt, int *dx, int *dy, bool gravidade)
{
	if(idMapa == 0 || idMapa>=C2D2M_MAX_MAPAS)
		return;
	// SE o mapa não foi inicializado, ou se a camada de marcas está na default (-1)
	if(!mapas[idMapa-1].inicializado || mapas[idMapa-1].camadaMarcas==-1)
		return;
	// REcupera o valor de x e y originais
	int x=xorig,y=yorig;
	// Recupera o mapa
	C2D2M_Mapa *mapa = &mapas[idMapa-1];
	// Bounding box
	int topo, baixo, esquerda, direita;
	// A referência do ator para inclinações, o quanto entra no bloco e a diferença de pontos
	int meio, entrou, dif;
	// Qual a maior distância percorrida (mais tarde, passa para o personagem)
	int maior;
	// Qual o bloco
	int bloco;
	if(abs(*dx) > abs(*dy))
		maior = abs(*dx);
	else
		maior = abs(*dy);
	// O deslocamento no eixo a cada passo (mais tarde, passa para o personagem)
	int dxl=0, dyl=0;
	if(*dx>0)
		dxl=1;
	else if(*dx < 0)
		dxl=-1;
	if(*dy>0)
		dyl=1;
	else if(*dy < 0)
		dyl=-1;
	// As variáveis para indicar se deve deslocar ou não
	int xant=0, yant=0;
	// Percorre os pixels no maior eixo
	for(int i = 1; i <= maior ; i++)
	{
		// Aplica o deslocamento no eixo x?
		if(dxl !=0 && (i * *dx)/maior != xant)
		{
			xant = (i * *dx)/maior;
			// Desloca
			x += dxl;
			// Calcula o bounding box
			topo = (y)/mapa->dimensaoBlocoV;
			baixo = (y+alt-1)/mapa->dimensaoBlocoV;
			esquerda = (x)/mapa->dimensaoBlocoH;
			direita = (x+larg-1)/mapa->dimensaoBlocoH;
			// Calcula o bloco em que se encontra o meio
			meio = (x+larg/2)/mapa->dimensaoBlocoH;
			// Testa a colisão com blocos inclinados
			if(meio >=0 && meio <= mapa->largura && mapa->dimensaoBlocoH == mapa->dimensaoBlocoV)
			{
				// ajusta pela parte de baixo
				if(baixo >= 0 && baixo<= mapa->altura)
				{
					bloco =mapa->camadas[mapa->camadaMarcas][mapa->largura*baixo+meio]-mapa->offbloco; 
					switch(bloco)
					{
					case C2D2M_SOLIDO45:
					case C2D2M_SOLIDO135:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO45)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = (baixo+1)*mapa->dimensaoBlocoV-1-(y+alt);
						// Aqui colide e ajusta
						if(dif < entrou)
							y -= entrou-dif;
							//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_BAIXO);
						// Não verifica a colisão na horizontal nesta linha
						baixo--;
						break;
					case C2D2M_SOLIDO22A:
					case C2D2M_SOLIDO157B:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO22A)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = (baixo+1)*mapa->dimensaoBlocoV-1-(y+alt);
						// Aqui colide e ajusta
						if(dif < entrou/2)
							y -= entrou/2-dif;
						// Não verifica a colisão na horizontal nesta linha
						baixo--;
						break;
					case C2D2M_SOLIDO22B:
					case C2D2M_SOLIDO157A:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO22B)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = (baixo+1)*mapa->dimensaoBlocoV-1-(y+alt);
						// Aqui colide e ajusta
						if(dif < (entrou+mapa->dimensaoBlocoV)/2)
						{
							y -= (entrou+mapa->dimensaoBlocoV)/2-dif;
							//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_BAIXO);
						}
						// Não verifica a colisão na horizontal nesta linha
						baixo--;
						break;
					}
				}

				// ajusta pela parte de cima
				if(topo >= 0 && topo<= mapa->altura)
				{
					bloco =mapa->camadas[mapa->camadaMarcas][mapa->largura*topo+meio]-mapa->offbloco; 
					switch(bloco)
					{
					case C2D2M_SOLIDO225:
					case C2D2M_SOLIDO315:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO315)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = y - (topo)*mapa->dimensaoBlocoV;
						// Aqui colide e ajusta
						if(dif < entrou)
							y += entrou-dif;
						// Não verifica a colisão na horizontal nesta linha
						topo++;
						break;
					case C2D2M_SOLIDO202B:
					case C2D2M_SOLIDO337A:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO337A)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = y - topo*mapa->dimensaoBlocoV;
						// Aqui colide e ajusta
						if(dif < entrou/2)
						{
							y += entrou/2-dif;
							//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_CIMA);
						}
						// Não verifica a colisão na horizontal nesta linha
						topo++;
						break;
					case C2D2M_SOLIDO202A:
					case C2D2M_SOLIDO337B:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO337B)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = y - topo*mapa->dimensaoBlocoV;
						// Aqui colide e ajusta
						if(dif < (entrou+mapa->dimensaoBlocoV)/2)
						{
							y += (entrou+mapa->dimensaoBlocoV)/2-dif;
							//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_CIMA);
						}
						// Não verifica a colisão na horizontal nesta linha
						topo++;
						break;
					}
				}
			}

			// Testa a colisão com blocos completamente sólidos
			for(int lin=topo;lin<=baixo;lin++)
			{
				// Testa se está dentro das coordenadas válidas
				if(lin < 0 || lin >= mapa->altura)
					continue;
				// Testa se ainda está dentro do mapa à esquerda 
				if(esquerda >= 0 && esquerda <= mapa->largura && dxl<0)
					// Testa se colidiu
					if(mapa->camadas[mapa->camadaMarcas][mapa->largura*lin+esquerda] == mapa->offbloco + C2D2M_SOLIDO)
					{
						// Se colidiu, aumenta um ponto e encerra
						x++; 
						break;
					}
				// Testa se ainda está dentro do mapa à direita 
				if(direita >= 0 && direita <= mapa->largura && dxl>0)
					// Testa se colidiu
					if(mapa->camadas[mapa->camadaMarcas][mapa->largura*lin+direita] == mapa->offbloco + C2D2M_SOLIDO)
					{
						// Se colidiu, diminui um ponto e encerra
						x--; 
						break;
					}
			}
		}
		// Teste de ajuste na vertical para quando não há gravidade
		if(dyl !=0 && (i * *dy)/maior != yant && !gravidade)
		{
			yant = (i * *dy)/maior;
			// Desloca
			y += dyl;
			// Calcula o bounding box
			topo = (y)/mapa->dimensaoBlocoV;
			baixo = (y+alt-1)/mapa->dimensaoBlocoV;
			esquerda = (x)/mapa->dimensaoBlocoH;
			direita = (x+larg-1)/mapa->dimensaoBlocoH;
			// Calcula o bloco em que se encontra o meio. Agora, o meio é na horizontal!
			meio = (y+alt/2)/mapa->dimensaoBlocoV;
			// Testa a colisão com blocos inclinados
			if(meio >=0 && meio <= mapa->altura && mapa->dimensaoBlocoH == mapa->dimensaoBlocoV)
			{
				// ajusta pela parte da esquerda
				if(esquerda >= 0 && esquerda<= mapa->largura)
				{
					bloco =mapa->camadas[mapa->camadaMarcas][mapa->largura*meio+esquerda]-mapa->offbloco; 
					switch(bloco)
					{
					case C2D2M_SOLIDO135:
					case C2D2M_SOLIDO225:
						entrou=y+alt/2 - meio*mapa->dimensaoBlocoV;
						if(bloco == C2D2M_SOLIDO135)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoV-entrou;						
						dif = x-esquerda*mapa->dimensaoBlocoH;
						// Aqui colide e ajusta
						if(dif < entrou)
							x += entrou-dif;
						// Encerra a verificação
						esquerda++;
						break;
					case C2D2M_SOLIDO157A:
					case C2D2M_SOLIDO202A:
						entrou=y+alt/2 - meio*mapa->dimensaoBlocoV;
						if(bloco == C2D2M_SOLIDO157A)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoV-entrou;						
						dif = x-esquerda*mapa->dimensaoBlocoH;
						// Aqui colide e ajusta
						if(dif < entrou*2)
						{
							x += entrou*2-dif;

						}
						// Encerra a verificação
						esquerda++;
						break;
					case C2D2M_SOLIDO157B:
					case C2D2M_SOLIDO202B:
						entrou=y+alt/2 - meio*mapa->dimensaoBlocoV;
						if(bloco == C2D2M_SOLIDO157B)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoV-entrou;						
						dif = x-esquerda*mapa->dimensaoBlocoH;
						// Aqui colide e ajusta
						if(dif < entrou*2 - mapa->dimensaoBlocoV)
						{
							x += entrou*2 - mapa->dimensaoBlocoV-dif;
						}
						// Encerra a verificação
						esquerda++;
						break;

					}
				}
				// ajusta pela parte da direita
				if(direita >= 0 && direita<= mapa->largura)
				{
					bloco =mapa->camadas[mapa->camadaMarcas][mapa->largura*meio+direita]-mapa->offbloco; 
					switch(bloco)
					{
					case C2D2M_SOLIDO45:
					case C2D2M_SOLIDO315:
						entrou=y +alt/2- meio*mapa->dimensaoBlocoV;
						if(bloco == C2D2M_SOLIDO45)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoV-entrou;						
						dif = (direita+1)*mapa->dimensaoBlocoH-1-(x+larg); 
						// Aqui colide e ajusta
						if(dif < entrou)
							x -= entrou-dif;
						// Encerra a verificação
						direita--;
						break;
					case C2D2M_SOLIDO22B:
					case C2D2M_SOLIDO337B:
						entrou=y +alt/2- meio*mapa->dimensaoBlocoV;
						if(bloco == C2D2M_SOLIDO22B)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoV-entrou;						
						dif = (direita+1)*mapa->dimensaoBlocoH-1-(x+larg); 
						// Aqui colide e ajusta
						if(dif < entrou*2)
						{
							x -= entrou*2-dif;
							//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_BAIXO);
						}
						// Encerra a verificação
						direita--;
						break;
					case C2D2M_SOLIDO22A:
					case C2D2M_SOLIDO337A:
						entrou=y +alt/2- meio*mapa->dimensaoBlocoV;
						if(bloco == C2D2M_SOLIDO22A)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoV-entrou;						
						dif = (direita+1)*mapa->dimensaoBlocoH-1-(x+larg); 
						// Aqui colide e ajusta
						if(dif < entrou*2-mapa->dimensaoBlocoV)
						{
							//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_BAIXO);
							x -= entrou*2-mapa->dimensaoBlocoV-dif;
						}
						// Encerra a verificação
						direita--;
						break;

					}

				}
			}
			// Testa a colisão com bloco completamente sólido na vertical
			for(int col=esquerda;col<=direita;col++)
			{
				// Testa se está dentro das coordenadas válidas
				if(col < 0 || col >= mapa->largura)
					continue;
				// Testa se ainda está dentro do mapa acima
				if(topo >= 0 && topo <= mapa->altura && dyl<0)
					// Testa se colidiu
					if(mapa->camadas[mapa->camadaMarcas][mapa->largura*topo+col] == mapa->offbloco + C2D2M_SOLIDO)
					{
						// Se colidiu, aumenta um ponto e encerra
						y++; //dxl;
						//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_CIMA);
						break;
					}
				// Testa se ainda está dentro do mapa abaixo 
				if(baixo >= 0 && baixo <= mapa->altura && dyl>0)
					// Testa se colidiu
					if(mapa->camadas[mapa->camadaMarcas][mapa->largura*baixo+col] == mapa->offbloco + C2D2M_SOLIDO)
					{
						// Se colidiu, diminui um ponto e encerra
						y--; //dxl;
						//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_BAIXO);
						break;
					}
			}


		}
		// Teste de ajuste na vertical para quando há gravidade e velocidade no y
		if(dyl != 0 && (i * *dy)/maior != yant && gravidade)
		{
			yant = (i * *dy)/maior;
			// Desloca
			y += dyl;
			// Calcula o bounding box
			topo = (y)/mapa->dimensaoBlocoV;
			baixo = (y+alt-1)/mapa->dimensaoBlocoV;
			esquerda = (x)/mapa->dimensaoBlocoH;
			direita = (x+larg-1)/mapa->dimensaoBlocoH;
			// Calcula o bloco em que se encontra o meio. Agora, o meio é na horizontal!
			meio = (x+larg/2)/mapa->dimensaoBlocoH;
			// Testa a colisão com blocos inclinados
			if(meio >=0 && meio <= mapa->largura && mapa->dimensaoBlocoH == mapa->dimensaoBlocoV)
			{
				// ajusta pela parte de baixo
				if(baixo >= 0 && baixo<= mapa->altura)
				{
					bloco =mapa->camadas[mapa->camadaMarcas][mapa->largura*baixo+meio]-mapa->offbloco; 
					switch(bloco)
					{
					case C2D2M_SOLIDO45:
					case C2D2M_SOLIDO135:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO45)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = (baixo+1)*mapa->dimensaoBlocoV-1-(y+alt);
						// Aqui colide e ajusta
						if(dif < entrou)
							y -= 1;//entrou-dif;
						// Não verifica a colisão na horizontal nesta linha
						//baixo--;
						esquerda++;
						break;
					case C2D2M_SOLIDO22A:
					case C2D2M_SOLIDO157B:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO22A)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = (baixo+1)*mapa->dimensaoBlocoV-1-(y+alt);
						// Aqui colide e ajusta
						if(dif < entrou/2)
							y --;//= entrou/2-dif;
						//baixo--;
						esquerda++;
						break;
					case C2D2M_SOLIDO22B:
					case C2D2M_SOLIDO157A:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO22B)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = (baixo+1)*mapa->dimensaoBlocoV-1-(y+alt);
						// Aqui colide e ajusta
						if(dif < (entrou+mapa->dimensaoBlocoV)/2)
						{
							y --;//= (entrou+mapa->dimensaoBlocoV)/2-dif;
						}
						// Não verifica a colisão na horizontal nesta linha
						//baixo--;
						esquerda++;
						break;
					}
				}

				// ajusta pela parte de cima
				if(topo >= 0 && topo<= mapa->altura)
				{
					bloco =mapa->camadas[mapa->camadaMarcas][mapa->largura*topo+meio]-mapa->offbloco; 
					switch(bloco)
					{
					case C2D2M_SOLIDO225:
					case C2D2M_SOLIDO315:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO315)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = y - (topo)*mapa->dimensaoBlocoV;
						// Aqui colide e ajusta
						if(dif < entrou)
							y += entrou-dif;
						//topo++;
						direita--;
						break;
					case C2D2M_SOLIDO202B:
					case C2D2M_SOLIDO337A:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO337A)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = y - topo*mapa->dimensaoBlocoV;
						// Aqui colide e ajusta
						if(dif < entrou/2)
							y += entrou/2-dif;
						// Não verifica a colisão na horizontal nesta linha
						//topo++;
						direita--;
						break;
					case C2D2M_SOLIDO202A:
					case C2D2M_SOLIDO337B:
						entrou=x+larg/2 - meio*mapa->dimensaoBlocoH;
						if(bloco == C2D2M_SOLIDO337B)
							entrou++;
						else
							entrou = mapa->dimensaoBlocoH-entrou;
						dif = y - topo*mapa->dimensaoBlocoV;
						// Aqui colide e ajusta
						if(dif < (entrou+mapa->dimensaoBlocoV)/2)
							y += (entrou+mapa->dimensaoBlocoV)/2-dif;

						// Não verifica a colisão na horizontal nesta linha
						//topo++;
						direita--;
						break;
					}
				}

			}
			// Testa a colisão com bloco completamente sólido na vertical
			for(int col=esquerda;col<=direita;col++)
			{
				// Testa se está dentro das coordenadas válidas
				if(col < 0 || col >= mapa->largura)
					continue;
				// Testa se ainda está dentro do mapa acima
				if(topo >= 0 && topo <= mapa->altura && dyl<0)
					// Testa se colidiu
					if(mapa->camadas[mapa->camadaMarcas][mapa->largura*topo+col] == mapa->offbloco + C2D2M_SOLIDO)
					{
						// Se colidiu, aumenta um ponto e encerra
						y++; //dxl;
						//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_CIMA);
						break;
					}
				// Testa se ainda está dentro do mapa abaixo 
				if(baixo >= 0 && baixo <= mapa->altura && dyl>0)
					// Testa se colidiu
					if(mapa->camadas[mapa->camadaMarcas][mapa->largura*baixo+col] == mapa->offbloco + C2D2M_SOLIDO)
					{
						// Se colidiu, diminui um ponto e encerra
						y--; //dxl;
						//ATOR_InsereEvento(a, EVT_COLIDIU_PAREDE_BAIXO);
						break;
					}
			}


		}



		// Para cada passo, verifica as colisões
		//ATOR_ColideBoundingBox(a, mapa);

	}
	// Atualiza o dx e dy
	*dx = x-xorig;
	*dy = y-yorig;
	return;// (cx || cy);
}

// Para um mapa, calcula a velocidade de um corpo de acordo com o tempo total da queda
// expresso em quadros (60 quadros por segundo)
bool C2D2M_CalculaQueda(unsigned int idMapa, int quadrosQueda, double *vqueda)
{
	if(idMapa == 0 || idMapa>=C2D2M_MAX_MAPAS)
		return false;
	// SE o mapa não foi inicializado, ou se a camada de marcas está na default (-1)
	if(!mapas[idMapa-1].inicializado || mapas[idMapa-1].camadaMarcas==-1)
		return false;
	
	// Recupera o mapa
	C2D2M_Mapa *mapa = &mapas[idMapa-1];
	// Se a gravidade do mapa for zerada ...
	if(mapa->gravidade == 0)
		return false;
	
    // Calcula o tempo, considerando 60 quadros por segundo
    double tempo = quadrosQueda*1.0/60.0;
    // Calcula a velocidade. 
	*vqueda = mapa->gravidade*tempo*tempo;
    // Limita a velocidade (""atrito com o ar"")
	if(*vqueda > mapa->maxgravidade/60.0)	
        *vqueda = mapa->maxgravidade/60.0;
    // Retorna o resultado
    return true;
}

// Testa se um bounding box colide com um bloco qualquer de cenário.
//
// Data: 28/08/2008
//
bool C2D2M_ColidiuBlocoCenario(unsigned int idMapa, int x, int y, int larg, int alt, int bloco)
{
	if(idMapa == 0 || idMapa>=C2D2M_MAX_MAPAS)
		return false;
	// SE o mapa não foi inicializado, ou se a camada de marcas está na default (-1)
	if(!mapas[idMapa-1].inicializado || mapas[idMapa-1].camadaMarcas==-1)
		return false;
	
	// Recupera o mapa
	C2D2M_Mapa *mapa = &mapas[idMapa-1];
	// Intervalo de blocos em que verificamos a colisão
	int topo, baixo, esquerda, direita;
	// Calcula o extremo esquerdo
	topo = y/mapa->dimensaoBlocoV;
	esquerda = x/mapa->dimensaoBlocoH;
	// Calcula o extremo direito
	baixo = (y+alt-1)/mapa->dimensaoBlocoV;
	direita = (x+larg-1)/mapa->dimensaoBlocoH;

	// Indica se houve colisao
	bool cxy=false;

	// Para cada bloco no intervalo
	for(int lin=topo;lin<=baixo && ! cxy;lin++)
		for(int col=esquerda;col<=direita && !cxy ;col++)
		{
			// O bloco é válido para colisão?
			// Ele é SE:
			//			- Ele está dentro do mapa
			//		- Se ele é bloco (ele pode ser colidido)
			// Testa então se está dentro do mapa
			if(lin< 0 || lin >= mapa->altura || col < 0 || col >= mapa->largura)
				continue;
			// Testa se ele é válido
			if(mapa->camadas[mapa->camadaMarcas][mapa->largura*lin+col]==mapa->offbloco+bloco)
				cxy = true;
		}
	return cxy;
}



// Método para verificar se o cabeçalho do FMP/FMA é correto
//
// Data: 26/01/2005
// Última atualização: 29/07/2007

bool C2D2M_VerificaCabecalhoArquivo(CabecalhoArquivo *cabecalho)
{
    // Está certo por definição
    bool ok=true;
    // Verifica se tem o FORM no começo
    for(int i=0;i<4;i++)
        if(cabecalho->tipo[i] != cabecalhos[0][i])
        {
            ok=false;
            break;
        }
    if(!ok)
        return ok;
    // Verifica se tem o FMAP no subtipo
    for(int i=0;i<4;i++)
        if(cabecalho->subtipo[i] != cabecalhos[1][i])
        {
            ok=false;
            break;
        }
    return ok;
}

// Função para verificar o tipo do cabeçalho. Retorna um dos tipos enumerados
//
// Data: 26/01/2005
// Última atualização: 29/07/2007

int C2D2M_TipoBloco(CabecalhoBloco *cabecalho)
{    
    // Verifica se é o bloco do MPHD no começo
    bool ok=true;
    for(int i=0;i<4;i++)
        if(cabecalho->tipo[i] != cabecalhos[2][i])
        {
            ok=false;
            break;
        }
    if(ok)
        return CABECALHO_MPHD;
    // Verifica se é o bloco do ANDT no começo
    ok=true;
    for(int i=0;i<4;i++)
        if(cabecalho->tipo[i] != cabecalhos[3][i])
        {
            ok=false;
            break;
        }
    if(ok)
        return CABECALHO_ANDT;
    // Verifica se é o bloco do BODY no começo
    ok=true;
    for(int i=0;i<4;i++)
        if(cabecalho->tipo[i] != cabecalhos[4][i])
        {
            ok=false;
            break;
        }
    if(ok)
        return CABECALHO_BODY;
    // Verifica se é uma camada (o quarto caracter é o número da camada)
    ok=true;
    for(int i=0;i<3;i++)
        if(cabecalho->tipo[i] != cabecalhos[5][i])
        {
            ok=false;
            break;
        }
    if(ok)
        return CABECALHO_LYR;  
    
    // Por default
    return CABECALHO_IGNORADO;
}

// Função que recupera a camazda de marcas
//
// Data: 30/01/2010
//
//
unsigned int C2D2M_PegaCamadaMarcas(unsigned int idMapa)
{
	// � um mapa v�lido?
	if(idMapa==0 || idMapa >= C2D2M_MAX_MAPAS)
		return -1;
        return(mapas[idMapa-1].camadaMarcas);
}

// Função para mudar o valor de um bloco em uma camada específica
//
// Data: 30/01/2010
// �ltima atualiza��o: 30/01/2010
//
void C2D2M_AlteraBloco(unsigned int idMapa, int camada, int x, int y, unsigned int valor)
{
    // � um mapa v�lido?
    if(idMapa==0 || idMapa >= C2D2M_MAX_MAPAS)
        return;
    // Se n�o foi inicializado, falha!
    if(!mapas[idMapa-1].inicializado)
        return;
    // A camada � v�lida?
    if(camada<0 || camada>=C2D2M_MAX_CAMADAS)
        return;
    // Pega o ponteiro do mapa (mais r�pido)
    C2D2M_Mapa *mapa = &mapas[idMapa-1];
    // Testa se o layer existe
    if(mapa->camadas[camada] == 0)
        return;

    // So muda o bloco se ele estiver dentro do mapa
    if(x<0 || y<0 || x>=mapa->largura || y>=mapa->altura)
        return;
    mapa->camadas[camada][mapa->largura*y+x]=valor+mapa->offbloco;

}
",16312,True,3073.302866171888,median
"// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	
=============================================================================*/

#include ""Components/ReflectionCaptureComponent.h""
#include ""Serialization/MemoryWriter.h""
#include ""UObject/RenderingObjectVersion.h""
#include ""UObject/ConstructorHelpers.h""
#include ""GameFramework/Actor.h""
#include ""RHI.h""
#include ""RenderingThread.h""
#include ""RenderResource.h""
#include ""Misc/ScopeLock.h""
#include ""Components/BillboardComponent.h""
#include ""Engine/CollisionProfile.h""
#include ""Serialization/MemoryReader.h""
#include ""UObject/UObjectHash.h""
#include ""UObject/UObjectIterator.h""
#include ""Engine/Texture2D.h""
#include ""SceneManagement.h""
#include ""Engine/ReflectionCapture.h""
#include ""DerivedDataCacheInterface.h""
#include ""Interfaces/ITargetPlatform.h""
#include ""EngineModule.h""
#include ""ShaderCompiler.h""
#include ""LoadTimesObjectVersion.h""
#include ""RenderingObjectVersion.h""
#include ""Engine/SphereReflectionCapture.h""
#include ""Components/SphereReflectionCaptureComponent.h""
#include ""Components/DrawSphereComponent.h""
#include ""Components/BoxReflectionCaptureComponent.h""
#include ""Engine/PlaneReflectionCapture.h""
#include ""Engine/BoxReflectionCapture.h""
#include ""Components/PlaneReflectionCaptureComponent.h""
#include ""Components/BoxComponent.h""
#include ""Components/SkyLightComponent.h""
#include ""ProfilingDebugging/CookStats.h""

#if ENABLE_COOK_STATS
namespace ReflectionCaptureCookStats
{
	static FCookStats::FDDCResourceUsageStats UsageStats;
	static FCookStatsManager::FAutoRegisterCallback RegisterCookStats([](FCookStatsManager::AddStatFuncRef AddStat)
	{
		UsageStats.LogStats(AddStat, TEXT(""ReflectionCapture.Usage""), TEXT(""""));
	});
}
#endif

// ES3.0+ devices support seamless cubemap filtering, averaging edges will produce artifacts on those devices
#define MOBILE_AVERAGE_CUBEMAP_EDGES 0 

/** 
 * Size of all reflection captures.
 * Reflection capture derived data versions must be changed if modifying this
 */
ENGINE_API TAutoConsoleVariable<int32> CVarReflectionCaptureSize(
	TEXT(""r.ReflectionCaptureResolution""),
	128,
	TEXT(""Set the resolution for all reflection capture cubemaps. Should be set via project's Render Settings. Must be power of 2. Defaults to 128.\\n"")
	);

static int32 SanatizeReflectionCaptureSize(int32 ReflectionCaptureSize)
{
	static const int32 MaxReflectionCaptureSize = 1024;
	static const int32 MinReflectionCaptureSize = 1;

	return FMath::Clamp(ReflectionCaptureSize, MinReflectionCaptureSize, MaxReflectionCaptureSize);
}

int32 UReflectionCaptureComponent::GetReflectionCaptureSize_GameThread()
{
	return SanatizeReflectionCaptureSize(CVarReflectionCaptureSize.GetValueOnGameThread());
}

int32 UReflectionCaptureComponent::GetReflectionCaptureSize_RenderThread()
{
	return SanatizeReflectionCaptureSize(CVarReflectionCaptureSize.GetValueOnRenderThread());
}


void UReflectionCaptureComponent::ReleaseHDRData()
{
	ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(
		ReleaseHDRData,
		FReflectionCaptureFullHDR*, FullHDRData, FullHDRData,
		{
			delete FullHDRData;
		});

	FullHDRData = nullptr;
}

void UWorld::UpdateAllReflectionCaptures()
{
	if ( FeatureLevel < ERHIFeatureLevel::SM4)
	{
		UE_LOG(LogMaterial, Warning, TEXT(""Update reflection captures only works with an active feature level of SM4 or greater.""));
		return;
	}
	
	TArray<UPackage*> Packages;	
	for (TObjectIterator<UReflectionCaptureComponent> It; It; ++It)
	{
		UReflectionCaptureComponent* CaptureComponent = *It;

		if (ContainsActor(CaptureComponent->GetOwner()) && !CaptureComponent->IsPendingKill())
		{
			// Purge cached derived data and force an update
			CaptureComponent->SetCaptureIsDirty();			
			Packages.AddUnique(CaptureComponent->GetOutermost());
		}
	}
	for (UPackage* Package : Packages)
	{
		if (Package)
		{
			// Need to dirty capture packages for new HDR data
			Package->MarkPackageDirty();
		}
	}
	UReflectionCaptureComponent::UpdateReflectionCaptureContents(this);
	
	for (TObjectIterator<USkyLightComponent> It; It; ++It)
	{
		USkyLightComponent* SkylightComponent = *It;
		if (ContainsActor(SkylightComponent->GetOwner()) && !SkylightComponent->IsPendingKill())
		{			
			SkylightComponent->SetCaptureIsDirty();			
		}
	}
	USkyLightComponent::UpdateSkyCaptureContents(this);
}

AReflectionCapture::AReflectionCapture(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	CaptureComponent = CreateAbstractDefaultSubobject<UReflectionCaptureComponent>(TEXT(""NewReflectionComponent""));

	bCanBeInCluster = true;

#if WITH_EDITORONLY_DATA
	SpriteComponent = CreateEditorOnlyDefaultSubobject<UBillboardComponent>(TEXT(""Sprite""));
	if (!IsRunningCommandlet() && (SpriteComponent != nullptr))
	{
		// Structure to hold one-time initialization
		struct FConstructorStatics
		{
			FName NAME_ReflectionCapture;
			ConstructorHelpers::FObjectFinderOptional<UTexture2D> DecalTexture;
			FConstructorStatics()
				: NAME_ReflectionCapture(TEXT(""ReflectionCapture""))
				, DecalTexture(TEXT(""/Engine/EditorResources/S_ReflActorIcon""))
			{
			}
		};
		static FConstructorStatics ConstructorStatics;

		SpriteComponent->Sprite = ConstructorStatics.DecalTexture.Get();
		SpriteComponent->RelativeScale3D = FVector(0.5f, 0.5f, 0.5f);
		SpriteComponent->bHiddenInGame = true;
		SpriteComponent->bAbsoluteScale = true;
		SpriteComponent->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
		SpriteComponent->bIsScreenSizeScaled = true;
	}

	CaptureOffsetComponent = CreateEditorOnlyDefaultSubobject<UBillboardComponent>(TEXT(""CaptureOffset""));
	if (!IsRunningCommandlet() && (CaptureOffsetComponent != nullptr))
	{
		// Structure to hold one-time initialization
		struct FConstructorStatics
		{
			FName NAME_ReflectionCapture;
			ConstructorHelpers::FObjectFinderOptional<UTexture2D> DecalTexture;
			FConstructorStatics()
				: NAME_ReflectionCapture(TEXT(""ReflectionCapture""))
				, DecalTexture(TEXT(""/Engine/EditorResources/S_ReflActorIcon""))
			{
			}
		};
		static FConstructorStatics ConstructorStatics;

		CaptureOffsetComponent->Sprite = ConstructorStatics.DecalTexture.Get();
		CaptureOffsetComponent->RelativeScale3D = FVector(0.2f, 0.2f, 0.2f);
		CaptureOffsetComponent->bHiddenInGame = true;
		CaptureOffsetComponent->bAbsoluteScale = true;
		CaptureOffsetComponent->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
		CaptureOffsetComponent->bIsScreenSizeScaled = true;
	}

	if (CaptureComponent)
	{
		CaptureComponent->CaptureOffsetComponent = CaptureOffsetComponent;
	}
	
#endif // WITH_EDITORONLY_DATA
}

#if WITH_EDITOR
void AReflectionCapture::PostEditMove(bool bFinished)
{
	Super::PostEditMove(bFinished);

	CaptureComponent->SetCaptureIsDirty();
}
#endif // WITH_EDITOR

ASphereReflectionCapture::ASphereReflectionCapture(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer.SetDefaultSubobjectClass<USphereReflectionCaptureComponent>(TEXT(""NewReflectionComponent"")))
{
	USphereReflectionCaptureComponent* SphereComponent = CastChecked<USphereReflectionCaptureComponent>(GetCaptureComponent());
	RootComponent = SphereComponent;
#if WITH_EDITORONLY_DATA
	if (GetSpriteComponent())
	{
		GetSpriteComponent()->SetupAttachment(SphereComponent);
	}
	if (GetCaptureOffsetComponent())
	{
		GetCaptureOffsetComponent()->SetupAttachment(SphereComponent);
	}
#endif	//WITH_EDITORONLY_DATA

	UDrawSphereComponent* DrawInfluenceRadius = CreateDefaultSubobject<UDrawSphereComponent>(TEXT(""DrawRadius0""));
	DrawInfluenceRadius->SetupAttachment(GetCaptureComponent());
	DrawInfluenceRadius->bDrawOnlyIfSelected = true;
	DrawInfluenceRadius->bUseEditorCompositing = true;
	DrawInfluenceRadius->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
	SphereComponent->PreviewInfluenceRadius = DrawInfluenceRadius;

	DrawCaptureRadius = CreateDefaultSubobject<UDrawSphereComponent>(TEXT(""DrawRadius1""));
	DrawCaptureRadius->SetupAttachment(GetCaptureComponent());
	DrawCaptureRadius->bDrawOnlyIfSelected = true;
	DrawCaptureRadius->bUseEditorCompositing = true;
	DrawCaptureRadius->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
	DrawCaptureRadius->ShapeColor = FColor(100, 90, 40);
}

#if WITH_EDITOR
void ASphereReflectionCapture::EditorApplyScale(const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown)
{
	USphereReflectionCaptureComponent* SphereComponent = Cast<USphereReflectionCaptureComponent>(GetCaptureComponent());
	check(SphereComponent);
	const FVector ModifiedScale = DeltaScale * ( AActor::bUsePercentageBasedScaling ? 5000.0f : 50.0f );
	FMath::ApplyScaleToFloat(SphereComponent->InfluenceRadius, ModifiedScale);
	GetCaptureComponent()->SetCaptureIsDirty();
	PostEditChange();
}

void APlaneReflectionCapture::EditorApplyScale(const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown)
{
	UPlaneReflectionCaptureComponent* PlaneComponent = Cast<UPlaneReflectionCaptureComponent>(GetCaptureComponent());
	check(PlaneComponent);
	const FVector ModifiedScale = DeltaScale * ( AActor::bUsePercentageBasedScaling ? 5000.0f : 50.0f );
	FMath::ApplyScaleToFloat(PlaneComponent->InfluenceRadiusScale, ModifiedScale);
	GetCaptureComponent()->SetCaptureIsDirty();
	PostEditChange();
}
#endif

ABoxReflectionCapture::ABoxReflectionCapture(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer.SetDefaultSubobjectClass<UBoxReflectionCaptureComponent>(TEXT(""NewReflectionComponent"")))
{
	UBoxReflectionCaptureComponent* BoxComponent = CastChecked<UBoxReflectionCaptureComponent>(GetCaptureComponent());
	BoxComponent->RelativeScale3D = FVector(1000, 1000, 400);
	RootComponent = BoxComponent;
#if WITH_EDITORONLY_DATA
	if (GetSpriteComponent())
	{
		GetSpriteComponent()->SetupAttachment(BoxComponent);
	}
	if (GetCaptureOffsetComponent())
	{
		GetCaptureOffsetComponent()->SetupAttachment(BoxComponent);
	}
#endif	//WITH_EDITORONLY_DATA
	UBoxComponent* DrawInfluenceBox = CreateDefaultSubobject<UBoxComponent>(TEXT(""DrawBox0""));
	DrawInfluenceBox->SetupAttachment(GetCaptureComponent());
	DrawInfluenceBox->bDrawOnlyIfSelected = true;
	DrawInfluenceBox->bUseEditorCompositing = true;
	DrawInfluenceBox->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
	DrawInfluenceBox->InitBoxExtent(FVector(1, 1, 1));
	BoxComponent->PreviewInfluenceBox = DrawInfluenceBox;

	UBoxComponent* DrawCaptureBox = CreateDefaultSubobject<UBoxComponent>(TEXT(""DrawBox1""));
	DrawCaptureBox->SetupAttachment(GetCaptureComponent());
	DrawCaptureBox->bDrawOnlyIfSelected = true;
	DrawCaptureBox->bUseEditorCompositing = true;
	DrawCaptureBox->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
	DrawCaptureBox->ShapeColor = FColor(100, 90, 40);
	DrawCaptureBox->InitBoxExtent(FVector(1, 1, 1));
	BoxComponent->PreviewCaptureBox = DrawCaptureBox;
}

APlaneReflectionCapture::APlaneReflectionCapture(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer.SetDefaultSubobjectClass<UPlaneReflectionCaptureComponent>(TEXT(""NewReflectionComponent"")))
{
	UPlaneReflectionCaptureComponent* PlaneComponent = CastChecked<UPlaneReflectionCaptureComponent>(GetCaptureComponent());
	PlaneComponent->RelativeScale3D = FVector(1, 1000, 1000);
	RootComponent = PlaneComponent;
#if WITH_EDITORONLY_DATA
	if (GetSpriteComponent())
	{
		GetSpriteComponent()->SetupAttachment(PlaneComponent);
	}
	if (GetCaptureOffsetComponent())
	{
		GetCaptureOffsetComponent()->SetupAttachment(PlaneComponent);
	}
#endif	//#if WITH_EDITORONLY_DATA
	UDrawSphereComponent* DrawInfluenceRadius = CreateDefaultSubobject<UDrawSphereComponent>(TEXT(""DrawRadius0""));
	DrawInfluenceRadius->SetupAttachment(GetCaptureComponent());
	DrawInfluenceRadius->bDrawOnlyIfSelected = true;
	DrawInfluenceRadius->bAbsoluteScale = true;
	DrawInfluenceRadius->bUseEditorCompositing = true;
	DrawInfluenceRadius->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
	PlaneComponent->PreviewInfluenceRadius = DrawInfluenceRadius;

	UBoxComponent* DrawCaptureBox = CreateDefaultSubobject<UBoxComponent>(TEXT(""DrawBox1""));
	DrawCaptureBox->SetupAttachment(GetCaptureComponent());
	DrawCaptureBox->bDrawOnlyIfSelected = true;
	DrawCaptureBox->bUseEditorCompositing = true;
	DrawCaptureBox->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
	DrawCaptureBox->ShapeColor = FColor(100, 90, 40);
	DrawCaptureBox->InitBoxExtent(FVector(1, 1, 1));
	PlaneComponent->PreviewCaptureBox = DrawCaptureBox;
}

// Generate a new guid to force a recapture of all reflection data
// Note: changing this will cause saved capture data in maps to be discarded
// A resave of those maps will be required to guarantee valid reflections when cooking for ES2
FGuid ReflectionCaptureDDCVer(0x0c669396, 0x9cb849ae, 0x9f4120ff, 0x5812f4d3);

// Bumping this version will invalidate only encoded capture data
#define REFLECTIONCAPTURE_ENCODED_DERIVEDDATA_VER 1

FReflectionCaptureFullHDR::~FReflectionCaptureFullHDR()
{
	DEC_MEMORY_STAT_BY(STAT_ReflectionCaptureMemory, CompressedCapturedData.GetAllocatedSize());
}

void FReflectionCaptureFullHDR::InitializeFromUncompressedData(const TArray<uint8>& UncompressedData, int32 InCubemapSize)
{
	CubemapSize = InCubemapSize;

	DEC_MEMORY_STAT_BY(STAT_ReflectionCaptureMemory, CompressedCapturedData.GetAllocatedSize());

	int32 UncompressedSize = UncompressedData.Num() * UncompressedData.GetTypeSize();

	TArray<uint8> TempCompressedMemory;
	// Compressed can be slightly larger than uncompressed
	TempCompressedMemory.Empty(UncompressedSize * 4 / 3);
	TempCompressedMemory.AddUninitialized(UncompressedSize * 4 / 3);
	int32 CompressedSize = TempCompressedMemory.Num() * TempCompressedMemory.GetTypeSize();

	verify(FCompression::CompressMemory(
		(ECompressionFlags)(COMPRESS_ZLIB | COMPRESS_BiasMemory), 
		TempCompressedMemory.GetData(), 
		CompressedSize, 
		UncompressedData.GetData(), 
		UncompressedSize));

	// Note: change REFLECTIONCAPTURE_FULL_DERIVEDDATA_VER when modifying the serialization layout
	FMemoryWriter FinalArchive(CompressedCapturedData, true);
	FinalArchive << UncompressedSize;
	FinalArchive << CompressedSize;
	FinalArchive.Serialize(TempCompressedMemory.GetData(), CompressedSize);

	INC_MEMORY_STAT_BY(STAT_ReflectionCaptureMemory, CompressedCapturedData.GetAllocatedSize());
}

TRefCountPtr<FReflectionCaptureUncompressedData> FReflectionCaptureFullHDR::GetUncompressedData() const
{
	// If we have serialized uncompressed data (from a cook), use it rather than uncompressing
	if (StoredUncompressedData)
	{
		return StoredUncompressedData;
	}
	else
	{
		check(CompressedCapturedData.Num() > 0);
		FMemoryReader Ar(CompressedCapturedData);

		// Note: change REFLECTIONCAPTURE_FULL_DERIVEDDATA_VER when modifying the serialization layout
		int32 UncompressedSize;
		Ar << UncompressedSize;

		int32 CompressedSize;
		Ar << CompressedSize;

		TRefCountPtr<FReflectionCaptureUncompressedData> UncompressedDataOut = new FReflectionCaptureUncompressedData(UncompressedSize);
		const uint8* SourceData = &CompressedCapturedData[Ar.Tell()];
		verify(FCompression::UncompressMemory((ECompressionFlags)COMPRESS_ZLIB, UncompressedDataOut->GetData(), UncompressedSize, SourceData, CompressedSize));
		return UncompressedDataOut;
	}
}

FColor RGBMEncode( FLinearColor Color )
{
	FColor Encoded;

	// Convert to gamma space
	Color.R = FMath::Sqrt( Color.R );
	Color.G = FMath::Sqrt( Color.G );
	Color.B = FMath::Sqrt( Color.B );

	// Range
	Color /= 16.0f;
	
	float MaxValue = FMath::Max( FMath::Max(Color.R, Color.G), FMath::Max(Color.B, DELTA) );
	
	if( MaxValue > 0.75f )
	{
		// Fit to valid range by leveling off intensity
		float Tonemapped = ( MaxValue - 0.75 * 0.75 ) / ( MaxValue - 0.5 );
		Color *= Tonemapped / MaxValue;
		MaxValue = Tonemapped;
	}

	Encoded.A = FMath::Min( FMath::CeilToInt( MaxValue * 255.0f ), 255 );
	Encoded.R = FMath::RoundToInt( ( Color.R * 255.0f / Encoded.A ) * 255.0f );
	Encoded.G = FMath::RoundToInt( ( Color.G * 255.0f / Encoded.A ) * 255.0f );
	Encoded.B = FMath::RoundToInt( ( Color.B * 255.0f / Encoded.A ) * 255.0f );

	return Encoded;
}

// Based off of CubemapGen
// https://code.google.com/p/cubemapgen/

#define FACE_X_POS 0
#define FACE_X_NEG 1
#define FACE_Y_POS 2
#define FACE_Y_NEG 3
#define FACE_Z_POS 4
#define FACE_Z_NEG 5

#define EDGE_LEFT   0	 // u = 0
#define EDGE_RIGHT  1	 // u = 1
#define EDGE_TOP    2	 // v = 0
#define EDGE_BOTTOM 3	 // v = 1

#define CORNER_NNN  0
#define CORNER_NNP  1
#define CORNER_NPN  2
#define CORNER_NPP  3
#define CORNER_PNN  4
#define CORNER_PNP  5
#define CORNER_PPN  6
#define CORNER_PPP  7

// D3D cube map face specification
//   mapping from 3D x,y,z cube map lookup coordinates 
//   to 2D within face u,v coordinates
//
//   --------------------> U direction 
//   |                   (within-face texture space)
//   |         _____
//   |        |     |
//   |        | +Y  |
//   |   _____|_____|_____ _____
//   |  |     |     |     |     |
//   |  | -X  | +Z  | +X  | -Z  |
//   |  |_____|_____|_____|_____|
//   |        |     |
//   |        | -Y  |
//   |        |_____|
//   |
//   v   V direction
//      (within-face texture space)

// Index by [Edge][FaceOrEdge]
static const int32 CubeEdgeListA[12][2] =
{
	{FACE_X_POS, EDGE_LEFT},
	{FACE_X_POS, EDGE_RIGHT},
	{FACE_X_POS, EDGE_TOP},
	{FACE_X_POS, EDGE_BOTTOM},

	{FACE_X_NEG, EDGE_LEFT},
	{FACE_X_NEG, EDGE_RIGHT},
	{FACE_X_NEG, EDGE_TOP},
	{FACE_X_NEG, EDGE_BOTTOM},

	{FACE_Z_POS, EDGE_TOP},
	{FACE_Z_POS, EDGE_BOTTOM},
	{FACE_Z_NEG, EDGE_TOP},
	{FACE_Z_NEG, EDGE_BOTTOM}
};

static const int32 CubeEdgeListB[12][2] =
{
	{FACE_Z_POS, EDGE_RIGHT },
	{FACE_Z_NEG, EDGE_LEFT  },
	{FACE_Y_POS, EDGE_RIGHT },
	{FACE_Y_NEG, EDGE_RIGHT },

	{FACE_Z_NEG, EDGE_RIGHT },
	{FACE_Z_POS, EDGE_LEFT  },
	{FACE_Y_POS, EDGE_LEFT  },
	{FACE_Y_NEG, EDGE_LEFT  },

	{FACE_Y_POS, EDGE_BOTTOM },
	{FACE_Y_NEG, EDGE_TOP    },
	{FACE_Y_POS, EDGE_TOP    },
	{FACE_Y_NEG, EDGE_BOTTOM },
};

// Index by [Face][Corner]
static const int32 CubeCornerList[6][4] =
{
	{ CORNER_PPP, CORNER_PPN, CORNER_PNP, CORNER_PNN },
	{ CORNER_NPN, CORNER_NPP, CORNER_NNN, CORNER_NNP },
	{ CORNER_NPN, CORNER_PPN, CORNER_NPP, CORNER_PPP },
	{ CORNER_NNP, CORNER_PNP, CORNER_NNN, CORNER_PNN },
	{ CORNER_NPP, CORNER_PPP, CORNER_NNP, CORNER_PNP },
	{ CORNER_PPN, CORNER_NPN, CORNER_PNN, CORNER_NNN }
};

static void EdgeWalkSetup( bool ReverseDirection, int32 Edge, int32 MipSize, int32& EdgeStart, int32& EdgeStep )
{
	if( ReverseDirection )
	{
		switch( Edge )
		{
		case EDGE_LEFT:		//start at lower left and walk up
			EdgeStart = MipSize * (MipSize - 1);
			EdgeStep = -MipSize;
			break;
		case EDGE_RIGHT:	//start at lower right and walk up
			EdgeStart = MipSize * (MipSize - 1) + (MipSize - 1);
			EdgeStep = -MipSize;
			break;
		case EDGE_TOP:		//start at upper right and walk left
			EdgeStart = (MipSize - 1);
			EdgeStep = -1;
			break;
		case EDGE_BOTTOM:	//start at lower right and walk left
			EdgeStart = MipSize * (MipSize - 1) + (MipSize - 1);
			EdgeStep = -1;
			break;
		}            
	}
	else
	{
		switch( Edge )
		{
		case EDGE_LEFT:		//start at upper left and walk down
			EdgeStart = 0;
			EdgeStep = MipSize;
			break;
		case EDGE_RIGHT:	//start at upper right and walk down
			EdgeStart = (MipSize - 1);
			EdgeStep = MipSize;
			break;
		case EDGE_TOP:		//start at upper left and walk left
			EdgeStart = 0;
			EdgeStep = 1;
			break;
		case EDGE_BOTTOM:	//start at lower left and walk left
			EdgeStart = MipSize * (MipSize - 1);
			EdgeStep = 1;
			break;
		}
	}
}

void FReflectionCaptureEncodedHDRDerivedData::GenerateFromDerivedDataSource(const FReflectionCaptureFullHDR& FullHDRData, float Brightness)
{
	const int32 NumMips = FMath::CeilLogTwo(FullHDRData.CubemapSize) + 1;

	TRefCountPtr<FReflectionCaptureUncompressedData> SourceCubemapData = FullHDRData.GetUncompressedData();

	int32 SourceMipBaseIndex = 0;
	int32 DestMipBaseIndex = 0;

	CapturedData = new FReflectionCaptureUncompressedData(SourceCubemapData->Size() * sizeof(FColor) / sizeof(FFloat16Color));

	// Note: change REFLECTIONCAPTURE_ENCODED_DERIVEDDATA_VER when modifying the encoded data layout or contents

	for (int32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
	{
		const int32 MipSize = 1 << (NumMips - MipIndex - 1);
		const int32 SourceCubeFaceBytes = MipSize * MipSize * sizeof(FFloat16Color);
		const int32 DestCubeFaceBytes = MipSize * MipSize * sizeof(FColor);

		const FFloat16Color*	MipSrcData = (const FFloat16Color*)SourceCubemapData->GetData(SourceMipBaseIndex);
		FColor*					MipDstData = (FColor*)CapturedData->GetData(DestMipBaseIndex);

#if MOBILE_AVERAGE_CUBEMAP_EDGES
		// Fix cubemap seams by averaging colors across edges
		int32 CornerTable[4] =
		{
			0,
			MipSize - 1,
			MipSize * (MipSize - 1),
			MipSize * (MipSize - 1) + MipSize - 1,
		};

		// Average corner colors
		FLinearColor AvgCornerColors[8];
		memset( AvgCornerColors, 0, sizeof( AvgCornerColors ) );
		for( int32 Face = 0; Face < CubeFace_MAX; Face++ )
		{
			const FFloat16Color* FaceSrcData = MipSrcData + Face * MipSize * MipSize;

			for( int32 Corner = 0; Corner < 4; Corner++ )
			{
				AvgCornerColors[ CubeCornerList[Face][Corner] ] += FLinearColor( FaceSrcData[ CornerTable[Corner] ] );
			}
		}

		// Encode corners
		for( int32 Face = 0; Face < CubeFace_MAX; Face++ )
		{
			FColor* FaceDstData = MipDstData + Face * MipSize * MipSize;

			for( int32 Corner = 0; Corner < 4; Corner++ )
			{
				const FLinearColor LinearColor = AvgCornerColors[ CubeCornerList[Face][Corner] ] / 3.0f;
				FaceDstData[ CornerTable[Corner] ] = RGBMEncode( LinearColor * Brightness );
			}
		}

		// Average edge colors
		for( int32 EdgeIndex = 0; EdgeIndex < 12; EdgeIndex++ )
		{
			int32 FaceA = CubeEdgeListA[ EdgeIndex ][0];
			int32 EdgeA = CubeEdgeListA[ EdgeIndex ][1];

			int32 FaceB = CubeEdgeListB[ EdgeIndex ][0];
			int32 EdgeB = CubeEdgeListB[ EdgeIndex ][1];

			const FFloat16Color*	FaceSrcDataA = MipSrcData + FaceA * MipSize * MipSize;
			FColor*					FaceDstDataA = MipDstData + FaceA * MipSize * MipSize;

			const FFloat16Color*	FaceSrcDataB = MipSrcData + FaceB * MipSize * MipSize;
			FColor*					FaceDstDataB = MipDstData + FaceB * MipSize * MipSize;

			int32 EdgeStartA = 0;
			int32 EdgeStepA = 0;
			int32 EdgeStartB = 0;
			int32 EdgeStepB = 0;

			EdgeWalkSetup( false, EdgeA, MipSize, EdgeStartA, EdgeStepA );
			EdgeWalkSetup( EdgeA == EdgeB || EdgeA + EdgeB == 3, EdgeB, MipSize, EdgeStartB, EdgeStepB );

			// Walk edge
			// Skip corners
			for( int32 Texel = 1; Texel < MipSize - 1; Texel++ )       
			{
				int32 EdgeTexelA = EdgeStartA + EdgeStepA * Texel;
				int32 EdgeTexelB = EdgeStartB + EdgeStepB * Texel;

				check( 0 <= EdgeTexelA && EdgeTexelA < MipSize * MipSize );
				check( 0 <= EdgeTexelB && EdgeTexelB < MipSize * MipSize );

				const FLinearColor EdgeColorA = FLinearColor( FaceSrcDataA[ EdgeTexelA ] );
				const FLinearColor EdgeColorB = FLinearColor( FaceSrcDataB[ EdgeTexelB ] );
				const FLinearColor AvgColor = 0.5f * ( EdgeColorA + EdgeColorB );
				
				FaceDstDataA[ EdgeTexelA ] = FaceDstDataB[ EdgeTexelB ] = RGBMEncode( AvgColor * Brightness );
			}
		}
#endif // MOBILE_AVERAGE_CUBEMAP_EDGES
		
		// Encode rest of texels
		for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
		{
			const int32 FaceSourceIndex = SourceMipBaseIndex + CubeFace * SourceCubeFaceBytes;
			const int32 FaceDestIndex = DestMipBaseIndex + CubeFace * DestCubeFaceBytes;
			const FFloat16Color* FaceSourceData = (const FFloat16Color*)SourceCubemapData->GetData(FaceSourceIndex);
			FColor* FaceDestData = (FColor*)CapturedData->GetData(FaceDestIndex);

			// Convert each texel from linear space FP16 to RGBM FColor
			// Note: Brightness on the capture is baked into the encoded HDR data
			// Skip edges
			const int32 SkipEdges = MOBILE_AVERAGE_CUBEMAP_EDGES ? 1 : 0;

			for( int32 y = SkipEdges; y < MipSize - SkipEdges; y++ )
			{
				for( int32 x = SkipEdges; x < MipSize - SkipEdges; x++ )
				{
					int32 TexelIndex = x + y * MipSize;
					const FLinearColor LinearColor = FLinearColor( FaceSourceData[ TexelIndex ]) * Brightness;
					FaceDestData[ TexelIndex ] = RGBMEncode( LinearColor );
				}
			}
		}

		SourceMipBaseIndex += SourceCubeFaceBytes * CubeFace_MAX;
		DestMipBaseIndex += DestCubeFaceBytes * CubeFace_MAX;
	}
}

FString FReflectionCaptureEncodedHDRDerivedData::GetDDCKeyString(const FGuid& StateId, int32 CubemapDimension)
{
	return FDerivedDataCacheInterface::BuildCacheKey(
		TEXT(""REFL_ENC""),
		*ReflectionCaptureDDCVer.ToString(),
		*StateId.ToString().Append(""_"").Append(FString::FromInt(CubemapDimension)).Append(""_"").Append(FString::FromInt(REFLECTIONCAPTURE_ENCODED_DERIVEDDATA_VER))
		);
}

FReflectionCaptureEncodedHDRDerivedData::~FReflectionCaptureEncodedHDRDerivedData()
{
}

TRefCountPtr<FReflectionCaptureEncodedHDRDerivedData> FReflectionCaptureEncodedHDRDerivedData::GenerateEncodedHDRData(const FReflectionCaptureFullHDR& FullHDRData, const FGuid& StateId, float Brightness)
{
	TRefCountPtr<FReflectionCaptureEncodedHDRDerivedData> EncodedHDRData = new FReflectionCaptureEncodedHDRDerivedData();
	const FString KeyString = GetDDCKeyString(StateId, FullHDRData.CubemapSize);

	COOK_STAT(auto Timer = ReflectionCaptureCookStats::UsageStats.TimeSyncWork());
	bool DDCHit = GetDerivedDataCacheRef().GetSynchronous(*KeyString, EncodedHDRData->CapturedData->GetArray() );
	if (!DDCHit)
	{
		EncodedHDRData->GenerateFromDerivedDataSource(FullHDRData, Brightness);

		if (EncodedHDRData->CapturedData->Size() > 0)
		{
			GetDerivedDataCacheRef().Put(*KeyString, EncodedHDRData->CapturedData->GetArray() );
		}
	}
	EncodedHDRData->CapturedData->UpdateMemoryTracking();
	COOK_STAT(Timer.AddHitOrMiss(DDCHit ? FCookStats::CallStats::EHitOrMiss::Hit : FCookStats::CallStats::EHitOrMiss::Miss, EncodedHDRData->CapturedData->Size()));

	check(EncodedHDRData->CapturedData->Size() > 0);
	return EncodedHDRData;
}

/** 
 * A cubemap texture resource that knows how to upload the packed capture data from a reflection capture. 
 * @todo - support texture streaming and compression
 */
class FReflectionTextureCubeResource : public FTexture
{
public:

	FReflectionTextureCubeResource() :
		Size(0),
		NumMips(0),
		Format(PF_Unknown)
	{}

	void SetupParameters(int32 InSize, int32 InNumMips, EPixelFormat InFormat, TRefCountPtr<FReflectionCaptureUncompressedData> InSourceData)
	{
		Size = InSize;
		NumMips = InNumMips;
		Format = InFormat;
		SourceData = InSourceData;
	}

	virtual void InitRHI() override
	{
		FRHIResourceCreateInfo CreateInfo;
		TextureCubeRHI = RHICreateTextureCube(Size, Format, NumMips, 0, CreateInfo);
		TextureRHI = TextureCubeRHI;

		if (SourceData)
		{
			check(SourceData->Size() > 0);

			const int32 BlockBytes = GPixelFormats[Format].BlockBytes;
			int32 MipBaseIndex = 0;

			for (int32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
			{
				const int32 MipSize = 1 << (NumMips - MipIndex - 1);
				const int32 CubeFaceBytes = MipSize * MipSize * BlockBytes;

				for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
				{
					uint32 DestStride = 0;
					uint8* DestBuffer = (uint8*)RHILockTextureCubeFace(TextureCubeRHI, CubeFace, 0, MipIndex, RLM_WriteOnly, DestStride, false);

					// Handle DestStride by copying each row
					for (int32 Y = 0; Y < MipSize; Y++)
					{
						uint8* DestPtr = ((uint8*)DestBuffer + Y * DestStride);
						const int32 SourceIndex = MipBaseIndex + CubeFace * CubeFaceBytes + Y * MipSize * BlockBytes;
						const uint8* SourcePtr = SourceData->GetData(SourceIndex);
						FMemory::Memcpy(DestPtr, SourcePtr, MipSize * BlockBytes);
					}

					RHIUnlockTextureCubeFace(TextureCubeRHI, CubeFace, 0, MipIndex, false);
				}

				MipBaseIndex += CubeFaceBytes * CubeFace_MAX;
			}

			if (!GIsEditor)
			{
				// Toss the source data now that we've created the cubemap
				// Note: can't do this if we ever use this texture resource in the editor and want to save the data later
				SourceData = nullptr;
			}
		}

		// Create the sampler state RHI resource.
		FSamplerStateInitializerRHI SamplerStateInitializer
		(
			SF_Trilinear,
			AM_Clamp,
			AM_Clamp,
			AM_Clamp
		);
		SamplerStateRHI = RHICreateSamplerState(SamplerStateInitializer);

		INC_MEMORY_STAT_BY(STAT_ReflectionCaptureTextureMemory,CalcTextureSize(Size,Size,Format,NumMips) * 6);
	}

	virtual void ReleaseRHI() override
	{
		DEC_MEMORY_STAT_BY(STAT_ReflectionCaptureTextureMemory,CalcTextureSize(Size,Size,Format,NumMips) * 6);
		TextureCubeRHI.SafeRelease();
		FTexture::ReleaseRHI();
	}

	virtual uint32 GetSizeX() const override
	{
		return Size;
	}

	virtual uint32 GetSizeY() const override //-V524
	{
		return Size;
	}

	FTextureRHIParamRef GetTextureRHI() 
	{
		return TextureCubeRHI;
	}

private:

	int32 Size;
	int32 NumMips;
	EPixelFormat Format;
	FTextureCubeRHIRef TextureCubeRHI;

	// Source data. Note that this is owned by the cubemap
	TRefCountPtr<FReflectionCaptureUncompressedData> SourceData;
};


TArray<UReflectionCaptureComponent*> UReflectionCaptureComponent::ReflectionCapturesToUpdate;
TArray<UReflectionCaptureComponent*> UReflectionCaptureComponent::ReflectionCapturesToUpdateForLoad;
FCriticalSection UReflectionCaptureComponent::ReflectionCapturesToUpdateForLoadLock;

UReflectionCaptureComponent::UReflectionCaptureComponent(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	Brightness = 1;
	// Shouldn't be able to change reflection captures at runtime
	Mobility = EComponentMobility::Static;

	bCaptureDirty = false;
	bDerivedDataDirty = false;
	bLoadedCookedData = false;
	AverageBrightness = 1.0f;
}

void UReflectionCaptureComponent::CreateRenderState_Concurrent()
{
	Super::CreateRenderState_Concurrent();

	UpdatePreviewShape();

	if (ShouldRender())
	{
		GetWorld()->Scene->AddReflectionCapture(this);
	}
}

void UReflectionCaptureComponent::SendRenderTransform_Concurrent()
{	
	// Don't update the transform of a component that needs to be recaptured,
	// Otherwise the RT will get the new transform one frame before the capture
	if (!bCaptureDirty)
	{
		UpdatePreviewShape();

		if (ShouldRender())
		{
			GetWorld()->Scene->UpdateReflectionCaptureTransform(this);
		}
	}

	Super::SendRenderTransform_Concurrent();
}

void UReflectionCaptureComponent::OnRegister()
{
	Super::OnRegister();

	UWorld* World = GetWorld();
	if (World->FeatureLevel < ERHIFeatureLevel::SM4)
	{
		if (EncodedHDRDerivedData == nullptr)
		{
			World->NumInvalidReflectionCaptureComponents+= 1;
		}
	}
}

void UReflectionCaptureComponent::OnUnregister()
{
	UWorld* World = GetWorld();
	if (World->FeatureLevel < ERHIFeatureLevel::SM4)
	{
		if (EncodedHDRDerivedData == nullptr && World->NumInvalidReflectionCaptureComponents > 0)
		{
			World->NumInvalidReflectionCaptureComponents-= 1;
		}
	}

	Super::OnUnregister();
}

void UReflectionCaptureComponent::DestroyRenderState_Concurrent()
{
	Super::DestroyRenderState_Concurrent();
	GetWorld()->Scene->RemoveReflectionCapture(this);
}

void UReflectionCaptureComponent::PostInitProperties()
{
	Super::PostInitProperties();

	// Create a new guid in case this is a newly created component
	// If not, this guid will be overwritten when serialized
	FPlatformMisc::CreateGuid(StateId);

	if (!HasAnyFlags(RF_ClassDefaultObject | RF_ArchetypeObject))
	{
		FScopeLock Lock(&ReflectionCapturesToUpdateForLoadLock);
		ReflectionCapturesToUpdateForLoad.AddUnique(this);
		bCaptureDirty = true; 
	}
}

void UReflectionCaptureComponent::SerializeSourceData(FArchive& Ar)
{
	if (Ar.UE4Ver() >= VER_UE4_REFLECTION_DATA_IN_PACKAGES)
	{
		if (Ar.IsSaving())
		{
			Ar << ReflectionCaptureDDCVer;
			Ar << AverageBrightness;

			int32 StartOffset = Ar.Tell();
			Ar << StartOffset;
			
			bool bValid = FullHDRData != NULL;
			Ar << bValid;

			if (FullHDRData)
			{
				Ar << FullHDRData->CubemapSize;
				Ar << FullHDRData->CompressedCapturedData;
			}

			int32 EndOffset = Ar.Tell();
			Ar.Seek(StartOffset);
			Ar << EndOffset;
			Ar.Seek(EndOffset);
		}
		else if (Ar.IsLoading())
		{
			FGuid SavedVersion;
			Ar << SavedVersion;

			if (Ar.CustomVer(FRenderingObjectVersion::GUID) >= FRenderingObjectVersion::ReflectionCapturesStoreAverageBrightness)
			{
				Ar << AverageBrightness;
			}

			int32 EndOffset = 0;
			Ar << EndOffset;

			if (SavedVersion != ReflectionCaptureDDCVer)
			{
				// Guid version of saved source data doesn't match latest, skip the data
				// The skipping is done so we don't have to maintain legacy serialization code paths when changing the format
				Ar.Seek(EndOffset);
			}
			else
			{
				bool bValid = false;
				Ar << bValid;

				if (bValid)
				{
					FullHDRData = new FReflectionCaptureFullHDR();

					if (Ar.CustomVer(FRenderingObjectVersion::GUID) >= FRenderingObjectVersion::CustomReflectionCaptureResolutionSupport)
					{
						Ar << FullHDRData->CubemapSize;
					}
					else
					{
						FullHDRData->CubemapSize = 128;
					}

					Ar << FullHDRData->CompressedCapturedData;

					INC_MEMORY_STAT_BY(STAT_ReflectionCaptureMemory, FullHDRData->CompressedCapturedData.GetAllocatedSize());
				}
			}
		}
	}
}

void UReflectionCaptureComponent::Serialize(FArchive& Ar)
{
	DECLARE_SCOPE_CYCLE_COUNTER(TEXT(""UReflectionCaptureComponent::Serialize""), STAT_ReflectionCaptureComponent_Serialize, STATGROUP_LoadTime);

	Ar.UsingCustomVersion(FRenderingObjectVersion::GUID);
	Ar.UsingCustomVersion(FLoadTimesObjectVersion::GUID);

	Super::Serialize(Ar);

	bool bCooked = false;

	if (Ar.UE4Ver() >= VER_UE4_REFLECTION_CAPTURE_COOKING)
	{
		bCooked = Ar.IsCooking() || bLoadedCookedData;
		// Save a bool indicating whether this is cooked data
		// This is needed when loading cooked data, to know to serialize differently
		Ar << bCooked;

		// Save the cooked bool in a member so that if this object was loaded with cooked data,
		// it can be saved correctly later, such as if it needs to be duplicated.
		if (Ar.IsLoading())
		{
			bLoadedCookedData = bCooked;
		}
	}

	if (FPlatformProperties::RequiresCookedData() && !bCooked && Ar.IsLoading())
	{
		UE_LOG(LogMaterial, Fatal, TEXT(""This platform requires cooked packages, and this reflection capture does not contain cooked data %s.""), *GetName());
	}

	if (bCooked)
	{
		static FName FullHDR(TEXT(""FullHDR""));
		static FName EncodedHDR(TEXT(""EncodedHDR""));

		// Saving for cooking, or previously loaded cooked data
		if (Ar.IsSaving())
		{
			Ar << AverageBrightness;

			TArray<FName> Formats;

			// Get all the reflection capture formats that the target platform wants
			if (Ar.IsCooking())
			{
				// Get all the reflection capture formats that the target platform wants
				Ar.CookingTarget()->GetReflectionCaptureFormats(Formats);
			}
			else
			{
				// Get the reflection capture formats that were loaded from cooked data
				Formats = LoadedFormats;
			}

			int32 NumFormats = Formats.Num();
			Ar << NumFormats;

			for (int32 FormatIndex = 0; FormatIndex < NumFormats; FormatIndex++)
			{
				FName CurrentFormat = Formats[FormatIndex];

				Ar << CurrentFormat;

				if (CurrentFormat == FullHDR)
				{
					// FullHDRData would have been set in PostLoad during cooking
					// Can't generate it if missing, since that requires rendering the scene
					bool bValid = FullHDRData != NULL;

					Ar << bValid;

					if (FullHDRData)
					{
						Ar << FullHDRData->CubemapSize;

						// Raw data needs to be uncompressed on cooked platforms to avoid decompression hitches
						TRefCountPtr<FReflectionCaptureUncompressedData> UncompressedData = FullHDRData->GetUncompressedData();
						Ar << UncompressedData->GetArray();
					}
				}
				else
				{
					check(CurrentFormat == EncodedHDR);

					TRefCountPtr<FReflectionCaptureEncodedHDRDerivedData> EncodedHDRData;
					
					// FullHDRData would have been set in PostLoad during cooking
					// Generate temporary encoded HDR data for saving
					if (FullHDRData != NULL && Ar.IsCooking())
					{
						EncodedHDRData = FReflectionCaptureEncodedHDRDerivedData::GenerateEncodedHDRData(*FullHDRData, StateId, Brightness);
					}
					
					bool bValid = EncodedHDRData != NULL;

					Ar << bValid;

					if (bValid)
					{
						Ar << EncodedHDRData->CapturedData->GetArray();
					}
					else if (!IsTemplate())
					{
						// Temporary warning until the cooker can do scene captures itself in the case of missing DDC
						UE_LOG(LogMaterial, Warning, TEXT(""Reflection capture requires encoded HDR data but none was found in the DDC!  This reflection will be black.""));
						UE_LOG(LogMaterial, Warning, TEXT(""Fix by resaving the map in the editor.  %s.""), *GetFullName());
					}
				}
			}
		}
		else
		{
			// Loading cooked data path
			Ar << AverageBrightness;

			int32 NumFormats = 0;
			Ar << NumFormats;

			LoadedFormats.SetNum(NumFormats);

			for (int32 FormatIndex = 0; FormatIndex < NumFormats; FormatIndex++)
			{
				FName CurrentFormat;
				Ar << CurrentFormat;
				LoadedFormats[FormatIndex] = CurrentFormat;

				bool bValid = false;
				Ar << bValid;

				if (bValid)
				{
					if (CurrentFormat == FullHDR)
					{
						FullHDRData = new FReflectionCaptureFullHDR();

						Ar << FullHDRData->CubemapSize;
						if (Ar.CustomVer(FLoadTimesObjectVersion::GUID) >= FLoadTimesObjectVersion::UncompressedReflectionCapturesForCookedBuilds)
						{
							// Raw data needs to be uncompressed on cooked platforms to avoid hitches
							FullHDRData->StoredUncompressedData = new FReflectionCaptureUncompressedData();
							Ar << FullHDRData->StoredUncompressedData->GetArray();
							FullHDRData->StoredUncompressedData->UpdateMemoryTracking();
						}
						else
						{
							Ar << FullHDRData->CompressedCapturedData;
							INC_MEMORY_STAT_BY(STAT_ReflectionCaptureMemory, FullHDRData->CompressedCapturedData.GetAllocatedSize());
						}
					}
					else 
					{
						check(CurrentFormat == EncodedHDR);
						EncodedHDRDerivedData = new FReflectionCaptureEncodedHDRDerivedData();
						Ar << EncodedHDRDerivedData->CapturedData->GetArray();
						EncodedHDRDerivedData->CapturedData->UpdateMemoryTracking();
					}
				}
				else if (CurrentFormat == EncodedHDR)
				{
					// Temporary warning until the cooker can do scene captures itself in the case of missing DDC
					UE_LOG(LogMaterial, Error, TEXT(""Reflection capture was loaded without any valid capture data and will be black.  This can happen if the DDC was not up to date during cooking.""));
					UE_LOG(LogMaterial, Error, TEXT(""Load the map in the editor once before cooking to fix.  %s.""), *GetFullName());
				}
			}
		}
	}
	else
	{
		SerializeSourceData(Ar);
	}
}

void UReflectionCaptureComponent::PostLoad()
{
	Super::PostLoad();

	bool bRetainAllFeatureLevelData = GIsEditor && GMaxRHIFeatureLevel >= ERHIFeatureLevel::SM4;
	bool bEncodedDataRequired = bRetainAllFeatureLevelData || (GMaxRHIFeatureLevel == ERHIFeatureLevel::ES2 || GMaxRHIFeatureLevel == ERHIFeatureLevel::ES3_1);
	bool bFullDataRequired = GMaxRHIFeatureLevel >= ERHIFeatureLevel::SM4;
	const int32 ReflectionCaptureSize = UReflectionCaptureComponent::GetReflectionCaptureSize_GameThread();

	// If we're loading on a platform that doesn't require cooked data, attempt to load missing data from the DDC
	if (!FPlatformProperties::RequiresCookedData())
	{
		// if we don't have the FullHDRData then recapture it since we are on a platform that can capture it.
		if (!FullHDRData || 
			FullHDRData->CubemapSize != ReflectionCaptureSize || 
			(EncodedHDRDerivedData && FullHDRData->CubemapSize != EncodedHDRDerivedData->CalculateCubemapDimension()))
		{
			bDerivedDataDirty = true;
			delete FullHDRData;
			FullHDRData = nullptr;
			EncodedHDRDerivedData = nullptr;
		}

		// If we have full HDR data but not encoded HDR data, generate the encoded data now
		if (FullHDRData 
			&& !EncodedHDRDerivedData 
			&& bEncodedDataRequired)
		{
			EncodedHDRDerivedData = FReflectionCaptureEncodedHDRDerivedData::GenerateEncodedHDRData(*FullHDRData, StateId, Brightness);
		}
	}
	
	// Initialize rendering resources for the current feature level, and toss data only needed by other feature levels (unless in editor mode, in which all feature level data should be resident.)
	if (FullHDRData && bFullDataRequired)
	{
		// Don't need encoded HDR data for rendering on this feature level
		INC_MEMORY_STAT_BY(STAT_ReflectionCaptureMemory, FullHDRData->CompressedCapturedData.GetAllocatedSize());

		if (GMaxRHIFeatureLevel == ERHIFeatureLevel::SM4)
		{
			SM4FullHDRCubemapTexture = new FReflectionTextureCubeResource();
			SM4FullHDRCubemapTexture->SetupParameters(FullHDRData->CubemapSize, FMath::CeilLogTwo(FullHDRData->CubemapSize) + 1, PF_FloatRGBA, FullHDRData->GetCapturedDataForSM4Load() );
			BeginInitResource(SM4FullHDRCubemapTexture);
		}

		if (!bEncodedDataRequired)
		{
			EncodedHDRDerivedData = nullptr;
		}
	}

	if (EncodedHDRDerivedData && bEncodedDataRequired)
	{
		int32 EncodedCubemapSize = EncodedHDRDerivedData->CalculateCubemapDimension();

		if (EncodedCubemapSize == ReflectionCaptureSize)
		{
			// Create a cubemap texture out of the encoded HDR data
			EncodedHDRCubemapTexture = new FReflectionTextureCubeResource();
			EncodedHDRCubemapTexture->SetupParameters(EncodedCubemapSize, FMath::CeilLogTwo(EncodedCubemapSize) + 1, PF_B8G8R8A8, EncodedHDRDerivedData->CapturedData);
			BeginInitResource(EncodedHDRCubemapTexture);
		}
		else
		{
			UE_LOG(
				LogMaterial,
				Error,
				TEXT(""Encoded reflection caputure resolution and project setting mismatch.\\n(Project Setting: %d, Encoded Reflection Capture: %d.\\nReflection cubemaps will be unavailable and cooking will fail.""), 
				CVarReflectionCaptureSize.GetValueOnGameThread(), 
				EncodedCubemapSize
				);
		}
		

		// free up the full hdr data if we no longer need it.
		if (FullHDRData && !bFullDataRequired)
		{
			delete FullHDRData;
			FullHDRData = NULL;
		}
	}
}

void UReflectionCaptureComponent::PreSave(const class ITargetPlatform* TargetPlatform)
{
	Super::PreSave(TargetPlatform);

	// This is done on save of the package, because this capture data can only be generated by the renderer
	// So we must make efforts to ensure that it is generated in the editor, because it can't be generated during cooking when missing
	// Note: This will only work when registered
	UWorld* World = GetWorld();
	if (World)
	{
		ReadbackFromGPU(World);
	}
}

void UReflectionCaptureComponent::PostDuplicate(bool bDuplicateForPIE)
{
	if (!bDuplicateForPIE)
	{
		// Reset the StateId on duplication since it needs to be unique for each capture.
		// PostDuplicate covers direct calls to StaticDuplicateObject, but not actor duplication (see PostEditImport)
		FPlatformMisc::CreateGuid(StateId);
	}
}

void UReflectionCaptureComponent::UpdateDerivedData(FReflectionCaptureFullHDR* NewDerivedData)
{
#if UE_SERVER
	delete FullHDRData;
#else
	if (FullHDRData)
	{
		// Delete the derived data on the rendering thread, since the rendering thread may be reading from its contents in FScene::UpdateReflectionCaptureContents
		ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER( 
			DeleteCaptureDataCommand,
			FReflectionCaptureFullHDR*, FullHDRData, FullHDRData,
		{
			delete FullHDRData;
		});
	}
#endif

	FullHDRData = NewDerivedData;
}

FReflectionCaptureProxy* UReflectionCaptureComponent::CreateSceneProxy()
{
	return new FReflectionCaptureProxy(this);
}

void UReflectionCaptureComponent::UpdatePreviewShape() 
{
	if (CaptureOffsetComponent)
	{
		CaptureOffsetComponent->RelativeLocation = CaptureOffset / GetComponentTransform().GetScale3D();
	}
}

#if WITH_EDITOR
bool UReflectionCaptureComponent::CanEditChange(const UProperty* Property) const
{
	bool bCanEditChange = Super::CanEditChange(Property);

	if (Property->GetFName() == GET_MEMBER_NAME_CHECKED(UReflectionCaptureComponent, Cubemap) ||
		Property->GetFName() == GET_MEMBER_NAME_CHECKED(UReflectionCaptureComponent, SourceCubemapAngle))
	{
		bCanEditChange &= ReflectionSourceType == EReflectionSourceType::SpecifiedCubemap;
	}

	return bCanEditChange;
}

void UReflectionCaptureComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
	// AActor::PostEditChange will ForceUpdateComponents()
	Super::PostEditChangeProperty(PropertyChangedEvent);

	if (PropertyChangedEvent.Property
		&& (PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UReflectionCaptureComponent, bVisible)
			|| (PropertyChangedEvent.MemberProperty && PropertyChangedEvent.MemberProperty->GetFName() == GET_MEMBER_NAME_CHECKED(UReflectionCaptureComponent, CaptureOffset))))
	{
		SetCaptureIsDirty();
	}
}

void UReflectionCaptureComponent::PostEditImport()
{
	Super::PostEditImport(); 

	// Generate a new StateId.  This is needed to cover actor duplication through alt-drag or copy-paste.
	SetCaptureIsDirty();
}
#endif // WITH_EDITOR

void UReflectionCaptureComponent::BeginDestroy()
{
	// Deregister the component from the update queue
	if (bCaptureDirty)
	{
		FScopeLock Lock(&ReflectionCapturesToUpdateForLoadLock);
		ReflectionCapturesToUpdate.Remove(this);
		ReflectionCapturesToUpdateForLoad.Remove(this);
	}

	// Have to do this because we can't use GetWorld in BeginDestroy
	for (TSet<FSceneInterface*>::TConstIterator SceneIt(GetRendererModule().GetAllocatedScenes()); SceneIt; ++SceneIt)
	{
		FSceneInterface* Scene = *SceneIt;
		Scene->ReleaseReflectionCubemap(this);
	}

	if (SM4FullHDRCubemapTexture)
	{
		BeginReleaseResource(SM4FullHDRCubemapTexture);
	}

	if (EncodedHDRCubemapTexture)
	{
		BeginReleaseResource(EncodedHDRCubemapTexture);
	}

	// Begin a fence to track the progress of the above BeginReleaseResource being completed on the RT
	ReleaseResourcesFence.BeginFence();

	Super::BeginDestroy();
}

bool UReflectionCaptureComponent::IsReadyForFinishDestroy()
{
	// Wait until the fence is complete before allowing destruction
	return Super::IsReadyForFinishDestroy() && ReleaseResourcesFence.IsFenceComplete();
}

void UReflectionCaptureComponent::FinishDestroy()
{
	UpdateDerivedData(NULL);

	if (SM4FullHDRCubemapTexture)
	{
		delete SM4FullHDRCubemapTexture;
		SM4FullHDRCubemapTexture = NULL;
	}

	if (EncodedHDRCubemapTexture)
	{
		delete EncodedHDRCubemapTexture;
		EncodedHDRCubemapTexture = NULL;
	}

	Super::FinishDestroy();
}

void UReflectionCaptureComponent::SetCaptureIsDirty() 
{ 
	if (bVisible)
	{
		UpdateDerivedData(NULL);
		FPlatformMisc::CreateGuid(StateId);
		bDerivedDataDirty = true;
		ReflectionCapturesToUpdate.AddUnique(this);
		bCaptureDirty = true; 
	}
}

void ReadbackFromSM4Cubemap_RenderingThread(FRHICommandListImmediate& RHICmdList, FReflectionTextureCubeResource* SM4FullHDRCubemapTexture, FReflectionCaptureFullHDR* OutDerivedData, int32 CubemapSize)
{
	const int32 EffectiveTopMipSize = CubemapSize;
	const int32 NumMips = FMath::CeilLogTwo(EffectiveTopMipSize) + 1;

	TArray<uint8> CaptureData;
	int32 CaptureDataSize = 0;

	for (int32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
	{
		const int32 MipSize = 1 << (NumMips - MipIndex - 1);

		for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
		{
			CaptureDataSize += MipSize * MipSize * sizeof(FFloat16Color);
		}
	}

	CaptureData.Empty(CaptureDataSize);
	CaptureData.AddZeroed(CaptureDataSize);
	int32 MipBaseIndex = 0;

	for (int32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
	{
		check(SM4FullHDRCubemapTexture->GetTextureRHI()->GetFormat() == PF_FloatRGBA);
		const int32 MipSize = 1 << (NumMips - MipIndex - 1);
		const int32 CubeFaceBytes = MipSize * MipSize * sizeof(FFloat16Color);

		for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
		{
			TArray<FFloat16Color> SurfaceData;
			// Read each mip face
			//@todo - do this without blocking the GPU so many times
			//@todo - pool the temporary textures in RHIReadSurfaceFloatData instead of always creating new ones
			RHICmdList.ReadSurfaceFloatData(SM4FullHDRCubemapTexture->GetTextureRHI(), FIntRect(0, 0, MipSize, MipSize), SurfaceData, (ECubeFace)CubeFace, 0, MipIndex);
			const int32 DestIndex = MipBaseIndex + CubeFace * CubeFaceBytes;
			uint8* FaceData = &CaptureData[DestIndex];
			check(SurfaceData.Num() * SurfaceData.GetTypeSize() == CubeFaceBytes);
			FMemory::Memcpy(FaceData, SurfaceData.GetData(), CubeFaceBytes);
		}

		MipBaseIndex += CubeFaceBytes * CubeFace_MAX;
	}

	OutDerivedData->InitializeFromUncompressedData(CaptureData, EffectiveTopMipSize);
}

void ReadbackFromSM4Cubemap(FReflectionTextureCubeResource* SM4FullHDRCubemapTexture, FReflectionCaptureFullHDR* OutDerivedData, int32 CubemapSize)
{
	ENQUEUE_UNIQUE_RENDER_COMMAND_THREEPARAMETER( 
		ReadbackReflectionData,
		FReflectionTextureCubeResource*, SM4FullHDRCubemapTexture, SM4FullHDRCubemapTexture,
		FReflectionCaptureFullHDR*, OutDerivedData, OutDerivedData,
		int32, CubemapSize, CubemapSize,
	{
		ReadbackFromSM4Cubemap_RenderingThread(RHICmdList, SM4FullHDRCubemapTexture, OutDerivedData, CubemapSize);
	});

	FlushRenderingCommands();
}

void UReflectionCaptureComponent::ReadbackFromGPU(UWorld* WorldToUpdate)
{
	if (WorldToUpdate == nullptr || WorldToUpdate->Scene == nullptr)
	{
		// This can happen during autosave
		return;
	}

	if (bDerivedDataDirty && (!IsRunningCommandlet() || IsAllowCommandletRendering()) && WorldToUpdate && WorldToUpdate->FeatureLevel >= ERHIFeatureLevel::SM4)
	{
		FReflectionCaptureFullHDR* NewDerivedData = new FReflectionCaptureFullHDR();

		if (WorldToUpdate->FeatureLevel == ERHIFeatureLevel::SM4)
		{
			if (SM4FullHDRCubemapTexture)
			{
				ensure(SM4FullHDRCubemapTexture->GetSizeX() == SM4FullHDRCubemapTexture->GetSizeY());
				ReadbackFromSM4Cubemap(SM4FullHDRCubemapTexture, NewDerivedData, int32(SM4FullHDRCubemapTexture->GetSizeX()));
			}
		}
		else
		{
			WorldToUpdate->Scene->GetReflectionCaptureData(this, *NewDerivedData);
		}

		if (NewDerivedData->CompressedCapturedData.Num() > 0)
		{
			// Update our copy in memory
			UpdateDerivedData(NewDerivedData);
		}
		else
		{
			delete NewDerivedData;
		}
	}
}

void UReflectionCaptureComponent::UpdateReflectionCaptureContents(UWorld* WorldToUpdate)
{
	if (WorldToUpdate->Scene 
		// Don't capture and read back capture contents if we are currently doing async shader compiling
		// This will keep the update requests in the queue until compiling finishes
		// Note: this will also prevent uploads of cubemaps from DDC, which is unintentional
		&& (GShaderCompilingManager == NULL || !GShaderCompilingManager->IsCompiling()))
	{
		TArray<UReflectionCaptureComponent*> WorldCombinedCaptures;

		for (int32 CaptureIndex = ReflectionCapturesToUpdate.Num() - 1; CaptureIndex >= 0; CaptureIndex--)
		{
			UReflectionCaptureComponent* CaptureComponent = ReflectionCapturesToUpdate[CaptureIndex];

			if (!CaptureComponent->GetOwner() || WorldToUpdate->ContainsActor(CaptureComponent->GetOwner()))
			{
				WorldCombinedCaptures.Add(CaptureComponent);
				ReflectionCapturesToUpdate.RemoveAt(CaptureIndex);
			}
		}

		TArray<UReflectionCaptureComponent*> WorldCapturesToUpdateForLoad;

		if (ReflectionCapturesToUpdateForLoad.Num() > 0)
		{
			FScopeLock Lock(&ReflectionCapturesToUpdateForLoadLock);
			for (int32 CaptureIndex = ReflectionCapturesToUpdateForLoad.Num() - 1; CaptureIndex >= 0; CaptureIndex--)
			{
				UReflectionCaptureComponent* CaptureComponent = ReflectionCapturesToUpdateForLoad[CaptureIndex];

				if (!CaptureComponent->GetOwner() || WorldToUpdate->ContainsActor(CaptureComponent->GetOwner()))
				{
					WorldCombinedCaptures.Add(CaptureComponent);
					WorldCapturesToUpdateForLoad.Add(CaptureComponent);
					ReflectionCapturesToUpdateForLoad.RemoveAt(CaptureIndex);
				}
			}
		}

		const auto FeatureLevel = WorldToUpdate->Scene->GetFeatureLevel();

		if (FeatureLevel == ERHIFeatureLevel::SM4)
		{
			for (int32 CaptureIndex = 0; CaptureIndex < WorldCombinedCaptures.Num(); CaptureIndex++)
			{
				UReflectionCaptureComponent* ReflectionComponent = WorldCombinedCaptures[CaptureIndex];

				if (!ReflectionComponent->SM4FullHDRCubemapTexture)
				{
					const int32 ReflectionCaptureSize = UReflectionCaptureComponent::GetReflectionCaptureSize_GameThread();

					// Create the cubemap if it wasn't already - this happens when updating a reflection capture that doesn't have valid DDC
					ReflectionComponent->SM4FullHDRCubemapTexture = new FReflectionTextureCubeResource();
					ReflectionComponent->SM4FullHDRCubemapTexture->SetupParameters(ReflectionCaptureSize, FMath::CeilLogTwo(ReflectionCaptureSize) + 1, PF_FloatRGBA, nullptr);
					BeginInitResource(ReflectionComponent->SM4FullHDRCubemapTexture);
					ReflectionComponent->MarkRenderStateDirty();
				}
			}
		}

		WorldToUpdate->Scene->AllocateReflectionCaptures(WorldCombinedCaptures);

		if (FeatureLevel >= ERHIFeatureLevel::SM4 && !FPlatformProperties::RequiresCookedData())
			{
				for (int32 CaptureIndex = 0; CaptureIndex < WorldCapturesToUpdateForLoad.Num(); CaptureIndex++)
				{
					// Save the derived data for any captures that were dirty on load
					// This allows the derived data to get cached without having to resave a map
					WorldCapturesToUpdateForLoad[CaptureIndex]->ReadbackFromGPU(WorldToUpdate);
				}
			}
	}
}

#if WITH_EDITOR
void UReflectionCaptureComponent::PreFeatureLevelChange(ERHIFeatureLevel::Type PendingFeatureLevel)
{
	if (PendingFeatureLevel == ERHIFeatureLevel::ES2 || PendingFeatureLevel == ERHIFeatureLevel::ES3_1)
	{
		// generate encoded hdr data for ES2 preview mode.
		UWorld* World = GetWorld();
		if (World != nullptr)
		{
			// Capture full hdr derived data first.
			ReadbackFromGPU(World);
		}

		if (FullHDRData)
		{
			EncodedHDRDerivedData = FReflectionCaptureEncodedHDRDerivedData::GenerateEncodedHDRData(*FullHDRData, StateId, Brightness);
			if (EncodedHDRCubemapTexture == nullptr)
			{
				EncodedHDRCubemapTexture = new FReflectionTextureCubeResource();
			}

			int32 EncodedCubemapSize = EncodedHDRDerivedData->CalculateCubemapDimension();

			EncodedHDRCubemapTexture->SetupParameters(EncodedCubemapSize, FMath::CeilLogTwo(EncodedCubemapSize) + 1, PF_B8G8R8A8, EncodedHDRDerivedData->CapturedData);
			BeginInitResource(EncodedHDRCubemapTexture);
		}
	}
	else
	{
		EncodedHDRDerivedData = nullptr;
		if (EncodedHDRCubemapTexture)
		{
			BeginReleaseResource(EncodedHDRCubemapTexture);
			FlushRenderingCommands();
			delete EncodedHDRCubemapTexture;
			EncodedHDRCubemapTexture = nullptr;
		}

		// for >= SM4 capture should be updated.
		SetCaptureIsDirty();
	}

	if (PendingFeatureLevel == ERHIFeatureLevel::SM4)
	{
		if (SM4FullHDRCubemapTexture == nullptr)
		{
			const int32 ReflectionCaptureSize = UReflectionCaptureComponent::GetReflectionCaptureSize_GameThread();

			SM4FullHDRCubemapTexture = new FReflectionTextureCubeResource();
			SM4FullHDRCubemapTexture->SetupParameters(ReflectionCaptureSize, FMath::CeilLogTwo(ReflectionCaptureSize) + 1, PF_FloatRGBA, nullptr);
			BeginInitResource(SM4FullHDRCubemapTexture);
		}
	}
	else
	{
		// release SM4 texture
		if (SM4FullHDRCubemapTexture != nullptr)
		{
			BeginReleaseResource(SM4FullHDRCubemapTexture);
			FlushRenderingCommands();
			delete SM4FullHDRCubemapTexture;
			SM4FullHDRCubemapTexture = nullptr;
		}
	}
}
#endif // WITH_EDITOR

USphereReflectionCaptureComponent::USphereReflectionCaptureComponent(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	InfluenceRadius = 3000;
}

void USphereReflectionCaptureComponent::UpdatePreviewShape()
{
	if (PreviewInfluenceRadius)
	{
		PreviewInfluenceRadius->InitSphereRadius(InfluenceRadius);
	}

	Super::UpdatePreviewShape();
}

#if WITH_EDITOR
void USphereReflectionCaptureComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
	// AActor::PostEditChange will ForceUpdateComponents()
	Super::PostEditChangeProperty(PropertyChangedEvent);

	if (PropertyChangedEvent.Property && 
		(PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(USphereReflectionCaptureComponent, InfluenceRadius)))
	{
		SetCaptureIsDirty();
	}
}
#endif // WITH_EDITOR

UBoxReflectionCaptureComponent::UBoxReflectionCaptureComponent(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	BoxTransitionDistance = 100;
}

void UBoxReflectionCaptureComponent::UpdatePreviewShape()
{
	if (PreviewCaptureBox)
	{
		PreviewCaptureBox->InitBoxExtent(((GetComponentTransform().GetScale3D() - FVector(BoxTransitionDistance)) / GetComponentTransform().GetScale3D()).ComponentMax(FVector::ZeroVector));
	}

	Super::UpdatePreviewShape();
}

float UBoxReflectionCaptureComponent::GetInfluenceBoundingRadius() const
{
	return (GetComponentTransform().GetScale3D() + FVector(BoxTransitionDistance)).Size();
}

#if WITH_EDITOR
void UBoxReflectionCaptureComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
	// AActor::PostEditChange will ForceUpdateComponents()
	Super::PostEditChangeProperty(PropertyChangedEvent);

	if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UBoxReflectionCaptureComponent, BoxTransitionDistance))
	{
		SetCaptureIsDirty();
	}
}
#endif // WITH_EDITOR

UPlaneReflectionCaptureComponent::UPlaneReflectionCaptureComponent(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	InfluenceRadiusScale = 2;
}

void UPlaneReflectionCaptureComponent::UpdatePreviewShape()
{
	if (PreviewInfluenceRadius)
	{
		PreviewInfluenceRadius->InitSphereRadius(GetInfluenceBoundingRadius());
	}

	Super::UpdatePreviewShape();
}

float UPlaneReflectionCaptureComponent::GetInfluenceBoundingRadius() const
{
	return FVector2D(GetComponentTransform().GetScale3D().Y, GetComponentTransform().GetScale3D().Z).Size() * InfluenceRadiusScale;
}

FReflectionCaptureProxy::FReflectionCaptureProxy(const UReflectionCaptureComponent* InComponent)
{
	PackedIndex = INDEX_NONE;
	CaptureOffset = InComponent->CaptureOffset;

	const USphereReflectionCaptureComponent* SphereComponent = Cast<const USphereReflectionCaptureComponent>(InComponent);
	const UBoxReflectionCaptureComponent* BoxComponent = Cast<const UBoxReflectionCaptureComponent>(InComponent);
	const UPlaneReflectionCaptureComponent* PlaneComponent = Cast<const UPlaneReflectionCaptureComponent>(InComponent);

	// Initialize shape specific settings
	Shape = EReflectionCaptureShape::Num;
	BoxTransitionDistance = 0;

	if (SphereComponent)
	{
		Shape = EReflectionCaptureShape::Sphere;
	}
	else if (BoxComponent)
	{
		Shape = EReflectionCaptureShape::Box;
		BoxTransitionDistance = BoxComponent->BoxTransitionDistance;
	}
	else if (PlaneComponent)
	{
		Shape = EReflectionCaptureShape::Plane;
	}
	else
	{
		check(0);
	}
	
	// Initialize common settings
	Component = InComponent;
	SM4FullHDRCubemap = InComponent->SM4FullHDRCubemapTexture;
	EncodedHDRCubemap = InComponent->EncodedHDRCubemapTexture;
	SetTransform(InComponent->GetComponentTransform().ToMatrixWithScale());
	InfluenceRadius = InComponent->GetInfluenceBoundingRadius();
	Brightness = InComponent->Brightness;
	Guid = GetTypeHash( Component->GetPathName() );
	AverageBrightness = 1.0f;

	ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(
		FInitReflectionProxy,
		const float*,AverageBrightness,InComponent->GetAverageBrightnessPtr(),
		FReflectionCaptureProxy*,ReflectionCaptureProxy,this,
	{
		// Only access AverageBrightness on the RT, even though they belong to the UReflectionCaptureComponent, 
		// Because FScene::UpdateReflectionCaptureContents does not block the RT so the writes could still be in flight
		ReflectionCaptureProxy->InitializeAverageBrightness(*AverageBrightness);
	});
}

void FReflectionCaptureProxy::InitializeAverageBrightness(const float& InAverageBrightness)
{
	AverageBrightness = InAverageBrightness;
}

void FReflectionCaptureProxy::SetTransform(const FMatrix& InTransform)
{
	Position = InTransform.GetOrigin();
	BoxTransform = InTransform.Inverse();

	FVector ForwardVector(1.0f,0.0f,0.0f);
	FVector RightVector(0.0f,-1.0f,0.0f);
	const FVector4 PlaneNormal = InTransform.TransformVector(ForwardVector);

	// Normalize the plane
	ReflectionPlane = FPlane(Position, FVector(PlaneNormal).GetSafeNormal());
	const FVector ReflectionXAxis = InTransform.TransformVector(RightVector);
	const FVector ScaleVector = InTransform.GetScaleVector();
	BoxScales = ScaleVector;
	// Include the owner's draw scale in the axes
	ReflectionXAxisAndYScale = ReflectionXAxis.GetSafeNormal() * ScaleVector.Y;
	ReflectionXAxisAndYScale.W = ScaleVector.Y / ScaleVector.Z;
}
",16321,True,2776.7646093372487,median
"[[netty-component]]
= Netty Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-netty/src/main/docs/netty-component.adoc
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with the Netty 4.x.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/netty.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Netty component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
 Netty is a NIO client server framework which enables quick and easy
development of networkServerInitializerFactory applications such as
protocol servers and clients. +
 Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.

This camel component supports both producer and consumer endpoints.

The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-netty</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

The URI scheme for a netty component is as follows

[source,text]
----
netty:tcp://0.0.0.0:99999[?options]
netty:udp://remotehost:99999/[?options]
----

This component supports producer and consumer endpoints for both TCP and
UDP.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Options

// component options: START
The Netty component supports 72 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (common) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *executorService* (consumer) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *maximumPoolSize* (consumer) | Sets a maximum thread pool size for the netty consumer ordered thread pool. The default size is 2 x cpu_core plus 1. Setting this value to eg 10 will then use 10 threads unless 2 x cpu_core plus 1 is a higher value, which then will override and be used. For example if there are 8 cores, then the consumer thread pool will be 17. This thread pool is used to route messages received from Netty by Camel. We use a separate thread pool to ensure ordering of messages and also in case some messages will block, then nettys worker threads (event loop) wont be affected. |  | int
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
|===
// component options: END


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

----
netty:protocol:host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. There are 2 enums and the value can be one of: tcp, udp |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (70 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

[NOTE]
====
Read below about using non shareable encoders/decoders.
====

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

Note that Object serialization is not allowed by default, and so a decoder must be configured.

[source,java]
----
@BindToRegistry(""decoder"")
public ChannelHandler getDecoder() throws Exception {
    return new DefaultChannelHandlerFactory() {
        @Override
        public ChannelHandler newChannelHandler() {
            return new DatagramPacketObjectDecoder(ClassResolvers.weakCachingResolver(null));
        }
    };
}

RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true&decoders=#decoder"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           // Process poetry in some way
           exchange.getOut().setBody(""Message received);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSLTLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::camel-spring-boot::page$netty-starter.adoc[]
",12461,False,2328.3033478087054,median
"== Default Parameters

These parameters are configured by the ownCloud installer, and are required
for your ownCloud server to operate.

=== instanceid

This is a unique identifier for your ownCloud installation, created
automatically by the installer. This example is for documentation only,
and you should never use it because it will not work. A valid `instanceid`
is created when you install ownCloud. Needs to start with a letter.

==== Code Sample

[source,php]
....
'instanceid' => 'd3c944a9a',
....

=== passwordsalt

The salt used to hash all passwords, auto-generated by the ownCloud
installer. (There are also per-user salts.) If you lose this salt you lose
all your passwords. This example is for documentation only, and you should
never use it.

==== Code Sample

[source,php]
....
'passwordsalt' => 'd3c944a9af095aa08f',
....

=== trusted_domains

Your list of trusted domains that users can log into. Specifying trusted
domains prevents host header poisoning. Do not remove this, as it performs
necessary security checks. Please consider that for backend processes like
background jobs or occ commands, the url parameter in key `overwrite.cli.url`
is used. For more details please see that key.

==== Code Sample

[source,php]
....
'trusted_domains' => [
    'demo.example.org',
    'otherdomain.example.org',
],
....

=== cors.allowed-domains

The global list of CORS domains. All users can use tools running CORS
requests from the listed domains.

==== Code Sample

[source,php]
....
'cors.allowed-domains' => [
    'https://foo.example.org',
],
....

=== datadirectory

Where user files are stored; this defaults to `data/` in the ownCloud
directory. The SQLite database is also stored here, when you use SQLite.
(SQLite is not available in ownCloud Enterprise Edition).

==== Code Sample

[source,php]
....
'datadirectory' => '/var/www/owncloud/data',
....

=== version

The current version number of your ownCloud installation. This is set up
during installation and update, so you shouldn't need to change it.

==== Code Sample

[source,php]
....
'version' => '',
....

=== version.hide

While hardening an ownCloud instance hiding the version information in status.php
can be a legitimate step. Please consult the documentation before enabling this.

==== Code Sample

[source,php]
....
'version.hide' => false,
....

=== show_server_hostname

Optionally, show the hostname of the server in status.php. Defaults to hidden.

==== Code Sample

[source,php]
....
'show_server_hostname' => false,
....

=== dbtype

Identifies the database used with this installation. See also config option
`supportedDatabases`.
Supported databases:

- mysql (MySQL/MariaDB)
- pgsql (PostgreSQL)
- sqlite (SQLite3 - Not in Enterprise Edition)
- oci (Oracle - Enterprise Edition Only)

==== Code Sample

[source,php]
....
'dbtype' => 'sqlite',
....

=== dbhost

Your host server name, for example `localhost`, `hostname`,
`hostname.example.com`, or the IP address. To specify a port use
`hostname:####`; to specify a Unix socket use `localhost:/path/to/socket`.

==== Code Sample

[source,php]
....
'dbhost' => '',
....

=== dbname

The name of the ownCloud database, which is set during installation. You
should not need to change this.

==== Code Sample

[source,php]
....
'dbname' => 'owncloud',
....

=== dbuser

The user that ownCloud uses to write to the database. This must be unique
across ownCloud instances using the same SQL database. This is set up during
installation, so you shouldn't need to change it.

==== Code Sample

[source,php]
....
'dbuser' => '',
....

=== dbpassword

The password for the database user.
This is set up during installation, so you shouldn't need to change it.

==== Code Sample

[source,php]
....
'dbpassword' => '',
....

=== dbtableprefix

Prefix for the ownCloud tables in the database.

==== Code Sample

[source,php]
....
'dbtableprefix' => '',
....

=== installed

Indicates whether the ownCloud instance was installed successfully; `true`
indicates a successful installation, and `false` indicates an unsuccessful
installation.

==== Code Sample

[source,php]
....
'installed' => false,
....

== User Experience

These optional parameters control some aspects of the user interface. Default
values, where present, are shown.

=== default_language

This sets the default language on your ownCloud server, using ISO_639-1
language codes such as `en` for English, `de` for German, and `fr` for
French. It overrides automatic language detection on public pages like login
or shared items. User's language preferences configured under ""personal ->
language"" override this setting after they have logged in.

==== Code Sample

[source,php]
....
'default_language' => 'en_GB',
....

=== defaultapp

Set the default app to open on login. Use the app names as they appear in the
URL after clicking them in the Apps menu, such as documents, calendar, and
gallery. You can use a comma-separated list of app names, so if the first
app is not enabled for a user then ownCloud will try the second one, and so
on. If no enabled apps are found it defaults to the Files app.

==== Code Sample

[source,php]
....
'defaultapp' => 'files',
....

=== knowledgebaseenabled

`true` enables the Help menu item in the user menu (top right of the
ownCloud Web interface). `false` removes the Help item.

==== Code Sample

[source,php]
....
'knowledgebaseenabled' => true,
....

=== enable_avatars

`true` enables avatars, or user profile photos. These appear on the User
page, on user's Personal pages and are used by some apps (contacts, mail,
etc). `false` disables them.

==== Code Sample

[source,php]
....
'enable_avatars' => true,
....

=== allow_user_to_change_display_name

`true` allows users to change their display names (on their Personal
pages), and `false` prevents them from changing their display names.

==== Code Sample

[source,php]
....
'allow_user_to_change_display_name' => true,
....

=== remember_login_cookie_lifetime

Lifetime of the remember login cookie, which is set when the user clicks the
`remember` checkbox on the login screen. The default is 15 days, expressed
in seconds.

==== Code Sample

[source,php]
....
'remember_login_cookie_lifetime' => 60*60*24*15,
....

=== session_lifetime

The lifetime of a session after inactivity; the default is 24 hours,
expressed in seconds.

==== Code Sample

[source,php]
....
'session_lifetime' => 60 * 60 * 24,
....

=== session_keepalive

Enable or disable session keep-alive when a user is logged in to the Web UI.
Enabling this sends a ""heartbeat"" to the server to keep it from timing out.

==== Code Sample

[source,php]
....
'session_keepalive' => true,
....

=== token_auth_enforced

Enforces token only authentication for apps and clients connecting to ownCloud.
If enabled, all access requests using the users password are blocked for enhanced security.
Users have to generate special app-passwords (tokens) for their apps or clients in their personal
settings which are further used for app or client authentication. Browser logon is not affected.

==== Code Sample

[source,php]
....
'token_auth_enforced' => false,
....

=== login.alternatives

Allows to specify additional login buttons on the logon screen for e.g., SSO integration.

==== Code Sample

[source,php]
....
'login.alternatives' => [
    [
        'href' => 'https://www.testshib.org/Shibboleth.sso/ProtectNetwork?target=https%3A%2F%2Fmy.owncloud.tld%2Flogin%2Fsso-saml%2F',
        'name' => 'ProtectNetwork',
        'img' => '/img/PN_sign-in.gif'
    ],
    [
        'href' => 'https://www.testshib.org/Shibboleth.sso/OpenIdP.org?target=https%3A%2F%2Fmy.owncloud.tld%2Flogin%2Fsso-saml%2F',
        'name' => 'OpenIdP.org',
        'img' => '/img/openidp.png'
    ],
],
....

=== csrf.disabled

Disable ownCloud's built-in CSRF protection mechanism.
In some specific setups CSRF protection is handled in the environment, e.g.,
running F5 ASM. In these cases the built-in mechanism is not needed and can be disabled.
Generally speaking, however, this config switch should be left unchanged.

WARNING: Leave this as is if you're not sure what it does.

==== Code Sample

[source,php]
....
'csrf.disabled' => false,
....

=== skeletondirectory

The directory where the skeleton files are located. These files will be
copied to the data directory of new users. Leave empty to not copy any
skeleton files.

==== Code Sample

[source,php]
....
'skeletondirectory' => '/path/to/owncloud/core/skeleton',
....

=== user_backends

The `user_backends` app (which needs to be enabled first) allows you to
configure alternate authentication backends.
Supported backends are:

- IMAP (OC_User_IMAP)
- SMB (OC_User_SMB)
- FTP (OC_User_FTP)

==== Code Sample

[source,php]
....
'user_backends' => [
    [
        'class' => 'OC_User_IMAP',
        'arguments' => [
            '{imap.gmail.com:993/imap/ssl}INBOX'
        ]
    ]
],
....

=== lost_password_link

If your user backend does not allow password resets (e.g., when it's a
read-only user backend like LDAP), you can specify a custom link, where the
user is redirected to, when clicking the ""reset password"" link after a failed
login-attempt.
In case you do not want to provide any link, replace the url with 'disabled'.

==== Code Sample

[source,php]
....
'lost_password_link' => 'https://example.org/link/to/password/reset',
....

=== accounts.enable_medial_search

Allow medial search on account properties like display name, user id, email,
and other search terms. Allows finding 'Alice' when searching for 'lic'.
May slow down user search. Disable this if you encounter slow username search
in the sharing dialog.

==== Code Sample

[source,php]
....
'accounts.enable_medial_search' => true,
....

=== user.search_min_length

Defines the minimum characters entered before a search returns results for
users or groups in the share auto-complete form. Lower values increase search
time especially for large backends.
Any exact matches to a user or group will be returned, even though less than
the minimum characters have been entered. The search is case insensitive.
e.g., entering ""tom"" will always return ""Tom"" if there is an exact match.

==== Code Sample

[source,php]
....
'user.search_min_length' => 2,
....

== Mail Parameters

These configure the email settings for ownCloud notifications and password
resets.

=== mail_domain

The return address that you want to appear on emails sent by the ownCloud
server, for example `oc-admin@example.com`, substituting your own domain,
of course.

==== Code Sample

[source,php]
....
'mail_domain' => 'example.com',
....

=== mail_from_address

FROM address that overrides the built-in `sharing-noreply` and
`lostpassword-noreply` FROM addresses.

==== Code Sample

[source,php]
....
'mail_from_address' => 'owncloud',
....

=== mail_smtpdebug

Enable SMTP class debugging.

==== Code Sample

[source,php]
....
'mail_smtpdebug' => false,
....

=== mail_smtpmode

Which mode to use for sending mail: `sendmail`, `smtp`, `qmail` or
`php`.
If you are using local or remote SMTP, set this to `smtp`.
If you are using PHP mail you must have an installed and working email system
on the server. The program used to send email is defined in the `php.ini`
file.

For the `sendmail` option you need an installed and working email system on
the server, with `/usr/sbin/sendmail` installed on your Unix system.
For `qmail` the binary is /var/qmail/bin/sendmail, and it must be installed
on your Unix system.

==== Code Sample

[source,php]
....
'mail_smtpmode' => 'sendmail',
....

=== mail_smtphost

This depends on `mail_smtpmode`. Specify the IP address of your mail
server host. This may contain multiple hosts separated by a semi-colon. If
you need to specify the port number append it to the IP address separated by
a colon, like this: `127.0.0.1:24`.

==== Code Sample

[source,php]
....
'mail_smtphost' => '127.0.0.1',
....

=== mail_smtpport

This depends on `mail_smtpmode`. Specify the port for sending mail.

==== Code Sample

[source,php]
....
'mail_smtpport' => 25,
....

=== mail_smtptimeout

This depends on `mail_smtpmode`. This sets the SMTP server timeout, in
seconds. You may need to increase this if you are running an anti-malware or
spam scanner.

==== Code Sample

[source,php]
....
'mail_smtptimeout' => 10,
....

=== mail_smtpsecure

This depends on `mail_smtpmode`.
Specify when you are using `ssl` or `tls`, or leave empty for no encryption.

==== Code Sample

[source,php]
....
'mail_smtpsecure' => '',
....

=== mail_smtpauth

This depends on `mail_smtpmode`. Change this to `true` if your mail
server requires authentication.

==== Code Sample

[source,php]
....
'mail_smtpauth' => false,
....

=== mail_smtpauthtype

This depends on `mail_smtpmode`. If SMTP authentication is required, choose
the authentication type as `LOGIN` (default) or `PLAIN`.

==== Code Sample

[source,php]
....
'mail_smtpauthtype' => 'LOGIN',
....

=== mail_smtpname

This depends on `mail_smtpauth`. Specify the username for authenticating to
the SMTP server.

==== Code Sample

[source,php]
....
'mail_smtpname' => '',
....

=== mail_smtppassword

This depends on `mail_smtpauth`. Specify the password for authenticating to
the SMTP server.

==== Code Sample

[source,php]
....
'mail_smtppassword' => '',
....

== Proxy Configurations

=== overwritehost

The automatic hostname detection of ownCloud can fail in certain reverse
proxy and CLI/cron situations. This option allows you to manually override
the automatic detection; for example `www.example.com`, or specify the port
`www.example.com:8080`.

==== Code Sample

[source,php]
....
'overwritehost' => '',
....

=== overwriteprotocol

When generating URLs, ownCloud attempts to detect whether the server is
accessed via `https` or `http`. However, if ownCloud is behind a proxy
and the proxy handles the `https` calls, ownCloud would not know that
`ssl` is in use, which would result in incorrect URLs being generated.
Valid values are `http` and `https`.

==== Code Sample

[source,php]
....
'overwriteprotocol' => '',
....

=== overwritewebroot

ownCloud attempts to detect the webroot for generating URLs automatically.
For example, if `www.example.com/owncloud` is the URL pointing to the
ownCloud instance, the webroot is `/owncloud`. When proxies are in use, it
may be difficult for ownCloud to detect this parameter, resulting in invalid
URLs.

==== Code Sample

[source,php]
....
'overwritewebroot' => '',
....

=== overwritecondaddr

This option allows you to define a manual override condition as a regular
expression for the remote IP address. The keys `overwritewebroot`,
`overwriteprotocol`, and `overwritehost` are subject to this condition.
For example, defining a range of IP  addresses starting with `10.0.0.`
and ending with 1 to 3: * `^10\\.0\\.0\\.[1-3]$`.

==== Code Sample

[source,php]
....
'overwritecondaddr' => '',
....

=== overwrite.cli.url

Use this configuration parameter to specify the base URL for any URLs which
are generated within ownCloud using any kind of command line tools (cron or
occ). The value should contain the full base URL: `https://www.example.com/owncloud`.
As an example, alerts shown in the browser to upgrade an app are triggered by
a cron background process and therefore uses the url of this key, even if the user
has logged on via a different domain defined in key `trusted_domains`. When the
user clicks an alert like this, he will be redirected to that URL and must logon again.

==== Code Sample

[source,php]
....
'overwrite.cli.url' => '',
....

=== htaccess.RewriteBase

To have clean URLs without `/index.php` this parameter needs to be configured.

This parameter will be written as ""RewriteBase"" on update and installation of
ownCloud to your `.htaccess` file. While this value is often simply the URL
path of the ownCloud installation it cannot be set automatically properly in
every scenario and needs thus some manual configuration.

In a standard Apache setup this usually equals the folder that ownCloud is
accessible at. So if ownCloud is accessible via ""https://mycloud.org/owncloud""
the correct value would most likely be ""/owncloud"". If ownCloud is running
under ""https://mycloud.org/"" then it would be ""/"".

Note that the above rule is not valid in every case, as there are some rare setup
cases where this may not apply. However, to avoid any update problems this
configuration value is explicitly opt-in.

After setting this value run `occ maintenance:update:htaccess`. Now, when the
following conditions are met ownCloud URLs won't contain `index.php`:

- `mod_rewrite` is installed
- `mod_env` is installed

==== Code Sample

[source,php]
....
'htaccess.RewriteBase' => '/',
....

=== proxy

The URL of your proxy server, for example `proxy.example.com:8081`.

==== Code Sample

[source,php]
....
'proxy' => '',
....

=== proxyuserpwd

The optional authentication for the proxy to use to connect to the internet.
The format is: `username:password`.

==== Code Sample

[source,php]
....
'proxyuserpwd' => '',
....

== Deleted Items (trash bin)

These parameters control the Deleted files app.

=== trashbin_retention_obligation

If the trash bin app is enabled (default), this setting defines the policy
for when files and folders in the trash bin will be permanently deleted.
The app allows for two settings, a minimum time for trash bin retention,
and a maximum time for trash bin retention.
Minimum time is the number of days a file will be kept, after which it
may be deleted. Maximum time is the number of days at which it is guaranteed
to be deleted.
Both minimum and maximum times can be set together to explicitly define
file and folder deletion. For migration purposes, this setting is installed
initially set to ""auto"", which is equivalent to the default setting in
ownCloud 8.1 and before.

Available values:

- `auto`
    default setting. Keeps files and folders in the deleted files for up to
    30 days, automatically deleting them (at any time) if space is needed.
    Note: files may not be removed if space is not required.
- `D, auto`
    keeps files and folders in the trash bin for D+ days, delete anytime if
    space needed (note: files may not be deleted if space is not needed)
- `auto, D`
    delete all files in the trash bin that are older than D days
    automatically, delete other files anytime if space needed
- `D1, D2`
    keep files and folders in the trash bin for at least D1 days and
    delete when exceeds D2 days
- `disabled`
    trash bin auto clean disabled, files and folders will be kept forever

==== Code Sample

[source,php]
....
'trashbin_retention_obligation' => 'auto',
....

=== trashbin_purge_limit

This setting defines percentage of free space occupied by deleted files
that triggers auto purging of deleted files for this user.

==== Code Sample

[source,php]
....
'trashbin_purge_limit' => 50,
....

== File versions

These parameters control the Versions app.

=== versions_retention_obligation

If the versions app is enabled (default), this setting defines the policy
for when versions will be permanently deleted.
The app allows for two settings, a minimum time for version retention,
and a maximum time for version retention.
Minimum time is the number of days a version will be kept, after which it
may be deleted. Maximum time is the number of days at which it is guaranteed
to be deleted.
Both minimum and maximum times can be set together to explicitly define
version deletion. For migration purposes, this setting is installed
initially set to ""auto"", which is equivalent to the default setting in
ownCloud 8.1 and before.

Available values:

- `auto`
    default setting. Automatically expire versions according to expire
    rules. Please refer to :doc:`../configuration/files/file_versioning` for
    more information.
- `D, auto`
    keep versions at least for D days, apply expire rules to all versions
    that are older than D days.
- `auto, D`
    delete all versions that are older than D days automatically, delete
    other versions according to expire rules.
- `D1, D2`
    keep versions for at least D1 days and delete when exceeds D2 days.
- `disabled`
    versions auto clean disabled, versions will be kept forever.

==== Code Sample

[source,php]
....
'versions_retention_obligation' => 'auto',
....

== ownCloud Verifications

ownCloud performs several verification checks. There are two options,
`true` and `false`.

=== updatechecker

Check if ownCloud is up-to-date and shows a notification if a new version is
available. This option is only applicable to ownCloud core. It is not
applicable to app updates.

==== Code Sample

[source,php]
....
'updatechecker' => true,
....

=== updater.server.url

URL that ownCloud should use to look for updates

==== Code Sample

[source,php]
....
'updater.server.url' => 'https://updates.owncloud.com/server/',
....

=== has_internet_connection

Is ownCloud connected to the Internet or running in a closed network?

==== Code Sample

[source,php]
....
'has_internet_connection' => true,
....

=== check_for_working_wellknown_setup

Allows ownCloud to verify a working .well-known URL redirects. This is done
by attempting to make a request from JS to
https://your-domain.com/.well-known/caldav/.

==== Code Sample

[source,php]
....
'check_for_working_wellknown_setup' => true,
....

=== config_is_read_only

In certain environments it is desired to have a read-only configuration file.
When this switch is set to `true` ownCloud will not verify whether the
configuration is writable. However, it will not be possible to configure
all options via the Web interface. Furthermore, when updating ownCloud
it is required to make the configuration file writable again for the update
process.

==== Code Sample

[source,php]
....
'config_is_read_only' => false,
....

=== operation.mode

This defines the mode of operations. The default value is 'single-instance'
which means that ownCloud is running on a single node, which might be the
most common operations mode. The only other possible value for now is
'clustered-instance' which means that ownCloud is running on at least 2
nodes. The mode of operations has various impact on the behavior of ownCloud.

==== Code Sample

[source,php]
....
'operation.mode' => 'single-instance',
....

== Logging

These parameters configure the logging options.
For additional information or advanced configuration, please see the logging
section in the documentation.

=== log_type

By default the ownCloud logs are sent to the `owncloud.log` file in the
default ownCloud data directory.
If syslogging is desired, set this parameter to `syslog`.
Setting this parameter to `errorlog` will use the PHP error_log function
for logging.

==== Code Sample

[source,php]
....
'log_type' => 'owncloud',
....

=== logfile

Log file path for the ownCloud logging type.
Defaults to `[datadirectory]/owncloud.log`.

==== Code Sample

[source,php]
....
'logfile' => '/var/log/owncloud.log',
....

=== loglevel

Loglevel to start logging at. Valid values are: 0 = Debug, 1 = Info, 2 =
Warning, 3 = Error, and 4 = Fatal. The default value is Warning.

==== Code Sample

[source,php]
....
'loglevel' => 2,
....

=== syslog_tag

If you maintain different instances and aggregate the logs, you may want
to distinguish between them. `syslog_tag` can be set per instance
with a unique id. Only available if `log_type` is set to `syslog`.
The default value is `ownCloud`.

==== Code Sample

[source,php]
....
'syslog_tag' => 'ownCloud',
....

=== log.syslog.format

The syslog format can be changed to remove or add information.
In addition to the %replacements% below %level% can be used, but it is used
as a dedicated parameter to the syslog logging facility anyway.

==== Code Sample

[source,php]
....
'log.syslog.format' => '[%reqId%][%remoteAddr%][%user%][%app%][%method%][%url%] %message%',
....

=== log.conditions

Log condition for log level increase based on conditions. Once one of these
conditions is met, the required log level is set to debug. This allows to
debug specific requests, users or apps.

Supported conditions:

- `shared_secret`: if a request parameter with the name `log_secret` is set to
               this value the condition is met
- `users`:  if the current request is done by one of the specified users,
               this condition is met
- `apps`:   if the log message is invoked by one of the specified apps,
               this condition is met
- `logfile`: the log message invoked by the specified apps get redirected to
    this logfile, this condition is met
    Note: Not applicable when using syslog.

Defaults to an empty array.

==== Code Sample

[source,php]
....
'log.conditions' => [
    [
        'shared_secret' => '57b58edb6637fe3059b3595cf9c41b9',
        'users' => [
            'user1'
        ],
        'apps' => [
            'files_texteditor'
        ],
        'logfile' => '/tmp/test.log'
    ],
    [
        'shared_secret' => '57b58edb6637fe3059b3595cf9c41b9',
        'users' => [
            'user1'
        ],
        'apps' => [
            'gallery'
        ],
        'logfile' => '/tmp/gallery.log'
    ],
],
....

=== logdateformat

This uses PHP.date formatting; see http://php.net/manual/en/function.date.php.

==== Code Sample

[source,php]
....
'logdateformat' => 'F d, Y H:i:s',
....

=== logtimezone

The default timezone for log files is UTC. You may change this; see
http://php.net/manual/en/timezones.php.

==== Code Sample

[source,php]
....
'logtimezone' => 'Europe/Berlin',
....

=== cron_log

Log successful cron runs.

==== Code Sample

[source,php]
....
'cron_log' => true,
....

=== log_rotate_size

Enables log rotation and limits the total size of the log files.
The default is 0 or false which disables log rotation.
Specify a size in bytes, for example 104857600
(100 megabytes = 100 * 1024 * 1024 bytes).
A new logfile is created with a new name when the old logfile reaches the defined limit.
If a rotated log file is already present, it will be overwritten.
If enabled, only the active log file and one rotated file are stored.

==== Code Sample

[source,php]
....
'log_rotate_size' => false,
....

== Alternate Code Locations

Some of the ownCloud code may be stored in alternate locations.

=== customclient_desktop, customclient_android, and customclient_ios

This section is for configuring the download links for ownCloud clients, as
seen in the first-run wizard and on Personal pages.

==== Code Sample

[source,php]
....
'customclient_desktop' => 'https://owncloud.org/install/#install-clients',
'customclient_android' => 'https://play.google.com/store/apps/details?id=com.owncloud.android',
'customclient_ios' => 'https://itunes.apple.com/us/app/owncloud/id543672169?mt=8',
....

=== apps_paths

If you want to store apps in a custom directory instead of ownCloud’s default
`/app`, you need to modify the `apps_paths` key. There, you need to add a
new associative array that contains three elements. These are:

- `path`     The absolute file system path to the custom app folder.
- `url`      The request path to that folder relative to the ownCloud web root, prefixed with /.
- `writable` Whether users can install apps in that folder. After the configuration is added,
               new apps will only install in a directory where writable is set to true.

The configuration example shows how to add a second directory, called `/apps-external`.
Here, new apps and updates are only written to the `/apps-external` directory.
This eases upgrade procedures of ownCloud where shipped apps are delivered to apps/ by default.
`OC::$SERVERROOT` points to the web root of your instance.
Please see the Apps Management description on how to move custom apps properly.

==== Code Sample

[source,php]
....
'apps_paths' => [
    [
        'path' => OC::$SERVERROOT . '/apps',
        'url' => '/apps',
        'writable' => false,
    ],
    [
        'path' => OC::$SERVERROOT . '/apps-external',
        'url' => '/apps-external',
        'writable' => true,
    ],
],
....

== Previews

ownCloud supports previews of image files, the covers of MP3 files, and text
files. These options control enabling and disabling previews, and thumbnail
size.

=== enable_previews

By default, ownCloud can generate previews for the following file types:

- Image files
- Covers of MP3 files
- Text documents

Valid values are `true`, to enable previews, or `false`, to disable previews.

==== Code Sample

[source,php]
....
'enable_previews' => true,
....

=== preview_max_x

The maximum width, in pixels, of a preview. A value of `null` means there
is no limit.

==== Code Sample

[source,php]
....
'preview_max_x' => 2048,
....

=== preview_max_y

The maximum height, in pixels, of a preview. A value of `null` means there
is no limit.

==== Code Sample

[source,php]
....
'preview_max_y' => 2048,
....

=== preview_max_scale_factor

If a lot of small pictures are stored on the ownCloud instance and the
preview system generates blurry previews, you might want to consider setting
a maximum scale factor. By default, pictures are upscaled to 10 times the
original size. A value of `1` or `null` disables scaling.

==== Code Sample

[source,php]
....
'preview_max_scale_factor' => 10,
....

=== preview_max_filesize_image

max file size for generating image previews with imagegd (default behaviour)
If the image is bigger, it'll try other preview generators,
but will most likely show the default mimetype icon.

Value represents the maximum file size in megabytes.
Default is 50.
Set to -1 for no limit.

==== Code Sample

[source,php]
....
'preview_max_filesize_image' => 50,
....

=== preview_libreoffice_path

custom path for LibreOffice/OpenOffice binary.

==== Code Sample

[source,php]
....
'preview_libreoffice_path' => '/usr/bin/libreoffice',
....

=== preview_office_cl_parameters

Use this if LibreOffice/OpenOffice requires additional arguments.

==== Code Sample

[source,php]
....
'preview_office_cl_parameters' =>
    ' --headless --nologo --nofirststartwizard --invisible --norestore '.
    '--convert-to pdf --outdir ',
....

=== enabledPreviewProviders

Only register providers that have been explicitly enabled.

The following providers are enabled by default:

- OC\\Preview\\PNG
- OC\\Preview\\JPEG
- OC\\Preview\\GIF
- OC\\Preview\\BMP
- OC\\Preview\\XBitmap
- OC\\Preview\\MarkDown
- OC\\Preview\\MP3
- OC\\Preview\\TXT

The following providers are disabled by default due to performance or privacy
concerns:

- OC\\Preview\\Illustrator
- OC\\Preview\\Movie
- OC\\Preview\\MSOffice2003
- OC\\Preview\\MSOffice2007
- OC\\Preview\\MSOfficeDoc
- OC\\Preview\\OpenDocument
- OC\\Preview\\PDF
- OC\\Preview\\Photoshop
- OC\\Preview\\Postscript
- OC\\Preview\\StarOffice
- OC\\Preview\\SVG
- OC\\Preview\\TIFF
- OC\\Preview\\Font

.. note:: Troubleshooting steps for the MS Word previews are available
   at the :doc:`../configuration/files/collaborative_documents_configuration`
   section of the Administrators Manual.

The following providers are not available in Microsoft Windows:

- OC\\Preview\\Movie
- OC\\Preview\\MSOfficeDoc
- OC\\Preview\\MSOffice2003
- OC\\Preview\\MSOffice2007
- OC\\Preview\\OpenDocument
- OC\\Preview\\StarOffice

==== Code Sample

[source,php]
....
'enabledPreviewProviders' => [
    'OC\\Preview\\PNG',
    'OC\\Preview\\JPEG',
    'OC\\Preview\\GIF',
    'OC\\Preview\\BMP',
    'OC\\Preview\\XBitmap',
    'OC\\Preview\\MP3',
    'OC\\Preview\\TXT',
    'OC\\Preview\\MarkDown'
],
....

== Comments

Global settings for the Comments infrastructure.

=== comments.managerFactory

Replaces the default Comments Manager Factory. This can be utilized if an
own or 3rdParty CommentsManager should be used that – for instance – uses the
filesystem instead of the database to keep the comments.

==== Code Sample

[source,php]
....
'comments.managerFactory' => '\\OC\\Comments\\ManagerFactory',
....

=== systemtags.managerFactory

Replaces the default System Tags Manager Factory. This can be utilized if an
own or 3rdParty SystemTagsManager should be used that – for instance – uses the
filesystem instead of the database to keep the tags.

==== Code Sample

[source,php]
....
'systemtags.managerFactory' => '\\OC\\SystemTag\\ManagerFactory',
....

== Maintenance

These options are for halting user activity when you are performing server
maintenance.

=== maintenance

Enable maintenance mode to disable ownCloud.
If you want to prevent users from logging in to ownCloud before you start
doing some maintenance work, you need to set the value of the maintenance
parameter to true. Please keep in mind that users who are already logged-in
are kicked out of ownCloud instantly.

==== Code Sample

[source,php]
....
'maintenance' => false,
....

=== singleuser

When set to `true`, the ownCloud instance will be unavailable for all users
who are not in the `admin` group.

==== Code Sample

[source,php]
....
'singleuser' => false,
....

== SSL

=== openssl

Extra SSL options to be used for configuration.

==== Code Sample

[source,php]
....
'openssl' => [
    'config' => '/absolute/location/of/openssl.cnf',
],
....

=== enable_certificate_management

Allow the configuration of system wide trusted certificates.

==== Code Sample

[source,php]
....
'enable_certificate_management' => false,
....

== Memory caching backend configuration

Available cache backends:

* `\\OC\\Memcache\\APC`        Alternative PHP Cache backend
* `\\OC\\Memcache\\APCu`       APC user backend
* `\\OC\\Memcache\\ArrayCache` In-memory array-based backend (not recommended)
* `\\OC\\Memcache\\Memcached`  Memcached backend
* `\\OC\\Memcache\\Redis`      Redis backend
* `\\OC\\Memcache\\XCache`     XCache backend

Advice on choosing between the various backends:

* APCu should be easiest to install. Almost all distributions have packages.
  Use this for single user environment for all caches.
* Use Redis or Memcached for distributed environments.
  For the local cache (you can configure two) take APCu.

=== memcache.local

Memory caching backend for locally stored data.
Used for host-specific data, e.g., file paths.

==== Code Sample

[source,php]
....
'memcache.local' => '\\OC\\Memcache\\APCu',
....

=== memcache.distributed

Memory caching backend for distributed data.
Used for installation-specific data, e.g., database caching
If unset, defaults to the value of memcache.local.

==== Code Sample

[source,php]
....
'memcache.distributed' => '\\OC\\Memcache\\Memcached',
....

=== redis

Connection details for redis to use for memory caching in a single server configuration.

For enhanced security it is recommended to configure Redis
to require a password. See http://redis.io/topics/security
for more information.

==== Code Sample

[source,php]
....
'redis' => [
    'host' => 'localhost', // Can also be a unix domain socket: '/tmp/redis.sock'.
    'port' => 6379,
    'timeout' => 0.0,
    'password' => '',      // Optional, if not defined no password will be used.
    'dbindex' => 0,        // Optional, if undefined SELECT will not run and will use Redis Server's default DB Index.
],
....

=== redis.cluster

Connection details for a Redis Cluster
Only for use with Redis Clustering, for Sentinel-based setups use the single
server configuration above, and perform HA on the hostname.
Redis Cluster support requires the php module phpredis in version 3.0.0 or higher.

Available failover modes:

- \\RedisCluster::FAILOVER_NONE - only send commands to master nodes (default)
- \\RedisCluster::FAILOVER_ERROR - failover to slaves for read commands if master is unavailable
- \\RedisCluster::FAILOVER_DISTRIBUTE - randomly distribute read commands across master and slaves

==== Code Sample

[source,php]
....
'redis.cluster' => [
    'seeds' => [ // provide some/all of the cluster servers to bootstrap discovery, port required
        'localhost:7000',
        'localhost:7001'
    ],
    'timeout' => 0.0,
    'read_timeout' => 0.0,
    'failover_mode' => \\RedisCluster::FAILOVER_DISTRIBUTE
],
....

=== memcached_servers

Server details for one or more memcached servers to use for memory caching.

==== Code Sample

[source,php]
....
'memcached_servers' => [
    // hostname, port and optional weight. Also see:
    // http://www.php.net/manual/en/memcached.addservers.php
    // http://www.php.net/manual/en/memcached.addserver.php
    [
        'localhost',
        11211
    ],
    //['other.host.local', 11211],
],
....

=== memcached_options

Connection options for memcached.

==== Code Sample

[source,php]
....
'memcached_options' => [
    // Set timeouts to 50ms
    \\Memcached::OPT_CONNECT_TIMEOUT => 50,
    \\Memcached::OPT_RETRY_TIMEOUT =>   50,
    \\Memcached::OPT_SEND_TIMEOUT =>    50,
    \\Memcached::OPT_RECV_TIMEOUT =>    50,
    \\Memcached::OPT_POLL_TIMEOUT =>    50,

    // Enable compression
    \\Memcached::OPT_COMPRESSION =>          true,

    // Turn on consistent hashing
    \\Memcached::OPT_LIBKETAMA_COMPATIBLE => true,

    // Enable Binary Protocol
    \\Memcached::OPT_BINARY_PROTOCOL =>      true,

    // Binary serializer will be enabled if the igbinary PECL module is available
    //\\Memcached::OPT_SERIALIZER => \\Memcached::SERIALIZER_IGBINARY,
],
....

=== cache_path

Location of the cache folder, defaults to `data/$user/cache` where
`$user` is the current user. When specified, the format will change to
`$cache_path/$user` where `$cache_path` is the configured cache directory
and `$user` is the user.

==== Code Sample

[source,php]
....
'cache_path' => '',
....

=== cache_chunk_gc_ttl

TTL of chunks located in the cache folder before they're removed by
garbage collection (in seconds). Increase this value if users have
issues uploading very large files via the ownCloud Client as upload isn't
completed within one day.

==== Code Sample

[source,php]
....
'cache_chunk_gc_ttl' => 86400, // 60 * 60 * 24 = 1 day
....

=== dav.chunk_base_dir

Location of the chunk folder, defaults to `data/$user/uploads` where
`$user` is the current user. When specified, the format will change to
`$dav.chunk_base_dir/$user` where `$dav.chunk_base_dir` is the configured
cache directory and `$user` is the user.

==== Code Sample

[source,php]
....
'dav.chunk_base_dir' => '',
....

== Sharing

Global settings for Sharing

=== sharing.managerFactory

Replaces the default Share Provider Factory. This can be utilized if
own or 3rdParty Share Providers are used that – for instance – use the
filesystem instead of the database to keep the share information.

==== Code Sample

[source,php]
....
'sharing.managerFactory' => '\\OC\\Share20\\ProviderFactory',
....

=== sharing.federation.allowHttpFallback

When talking with federated sharing server, allow falling back to HTTP
instead of hard forcing HTTPS.

==== Code Sample

[source,php]
....
'sharing.federation.allowHttpFallback' => false,
....

== All other configuration options

=== dbdriveroptions

Additional driver options for the database connection, eg. to enable SSL
encryption in MySQL or specify a custom wait timeout on a cheap hoster.

==== Code Sample

[source,php]
....
'dbdriveroptions' => [
    PDO::MYSQL_ATTR_SSL_CA => '/file/path/to/ca_cert.pem',
    PDO::MYSQL_ATTR_INIT_COMMAND => 'SET wait_timeout = 28800'
],
....

=== sqlite.journal_mode

sqlite3 journal mode can be specified using this configuration parameter -
can be 'WAL' or 'DELETE'.
See for more details https://www.sqlite.org/wal.html

==== Code Sample

[source,php]
....
'sqlite.journal_mode' => 'DELETE',
....

=== mysql.utf8mb4

During setup, if requirements are met (see below), this setting is set to true
and MySQL can handle 4 byte characters instead of 3 byte characters.

If you want to convert an existing 3-byte setup into a 4-byte setup please
set the parameters in MySQL as mentioned below and run the migration command:
 ./occ db:convert-mysql-charset
The config setting will be set automatically after a successful run.

Consult the documentation for more details.

MySQL requires a special setup for longer indexes (> 767 bytes) which are
needed:

[mysqld]
innodb_large_prefix=ON
innodb_file_format=Barracuda
innodb_file_per_table=ON

Tables will be created with

 * character set: utf8mb4
 * collation:     utf8mb4_bin
 * row_format:    compressed

See:

- https://dev.mysql.com/doc/refman/5.7/en/charset-unicode-utf8mb4.html
- https://dev.mysql.com/doc/refman/5.7/en/innodb-parameters.html#sysvar_innodb_large_prefix
- https://mariadb.com/kb/en/mariadb/xtradbinnodb-server-system-variables/#innodb_large_prefix
- http://www.tocker.ca/2013/10/31/benchmarking-innodb-page-compression-performance.html
- http://mechanics.flite.com/blog/2014/07/29/using-innodb-large-prefix-to-avoid-error-1071/

==== Code Sample

[source,php]
....
'mysql.utf8mb4' => false,
....

=== supportedDatabases

Database types that are supported for installation.

Available:

- sqlite (SQLite3 - Not in Enterprise Edition)
- mysql (MySQL)
- pgsql (PostgreSQL)
- oci (Oracle - Enterprise Edition Only)

==== Code Sample

[source,php]
....
'supportedDatabases' => [
    'sqlite',
    'mysql',
    'pgsql',
    'oci',
],
....

=== tempdirectory

Override where ownCloud stores temporary files. Useful in situations where
the system temporary directory is on a limited space ramdisk or is otherwise
restricted, or if external storages which do not support streaming are in
use.

The Web server user must have write access to this directory.

==== Code Sample

[source,php]
....
'tempdirectory' => '/tmp/owncloudtemp',
....

=== hashingCost

The hashing cost used by hashes generated by ownCloud.
Using a higher value requires more time and CPU power to calculate the hashes.
As this number grows, the amount of work (typically CPU time or memory) necessary
to compute the hash increases exponentially.

==== Code Sample

[source,php]
....
'hashingCost' => 10,
....

=== blacklisted_files

Blacklist a specific file or files and disallow the upload of files
with this name. `.htaccess` is blocked by default.
WARNING: Use this only if you know what you are doing!

==== Code Sample

[source,php]
....
'blacklisted_files' => [
    '.htaccess'
],
....

=== excluded_directories

Exclude specific directory names and disallow scanning, creating and renaming
using these names. Case insensitive.
Excluded directory names are queried at any path part like at the beginning,
in the middle or at the end and will not be further processed if found.
Please see the documentation for details and examples.
Use when the storage backend supports eg snapshot directories to be excluded.

WARNING: Use this only if you know what you are doing.

==== Code Sample

[source,php]
....
'excluded_directories' => [
    '.snapshot',
    '~snapshot',
],
....

=== integrity.excluded.files

Exclude files from the integrity checker command.

==== Code Sample

[source,php]
....
'integrity.excluded.files' => [
    '.DS_Store',
    'Thumbs.db',
    '.directory',
    '.webapp',
    '.htaccess',
    '.user.ini',
],
....

=== integrity.ignore.missing.app.signature

The list of apps that are allowed to have no signature.json. Besides
ownCloud apps, this is particularly useful when creating ownCloud themes,
because themes are treated as apps. The app is identified with it´s app-id.
The following example allows app-1 and theme-2 to have no signature.

==== Code Sample

[source,php]
....
'integrity.ignore.missing.app.signature' => [
    'app-id of app-1',
    'app-id of theme-2',
],
....

=== share_folder

Define a default folder for shared files and folders other than root.

==== Code Sample

[source,php]
....
'share_folder' => '/',
....

=== cipher

The default cipher for encrypting files. Currently AES-128-CFB and
AES-256-CFB are supported.

==== Code Sample

[source,php]
....
'cipher' => 'AES-256-CFB',
....

=== minimum.supported.desktop.version

The minimum ownCloud desktop client version that will be allowed to sync with
this server instance. All connections made from earlier clients will be denied
by the server. Defaults to the minimum officially supported ownCloud version at
the time of release of this server version.

When changing this, note that older unsupported versions of the ownCloud desktop
client may not function as expected, and could lead to permanent data loss for
clients or other unexpected results.

==== Code Sample

[source,php]
....
'minimum.supported.desktop.version' => '2.2.4',
....

=== quota_include_external_storage

EXPERIMENTAL: option whether to include external storage in quota
calculation, defaults to false.

==== Code Sample

[source,php]
....
'quota_include_external_storage' => false,
....

=== filesystem_check_changes

Specifies how often the local filesystem (the ownCloud data/ directory, and
NFS mounts in data/) is checked for changes made outside ownCloud. This
does not apply to external storages.

`0`: Never check the filesystem for outside changes, provides a performance
increase when it's certain that no changes are made directly to the
filesystem.

`1`: Check each file or folder at most once per request, recommended for
general use if outside changes might happen.

==== Code Sample

[source,php]
....
'filesystem_check_changes' => 0,
....

=== part_file_in_storage

By default ownCloud will store the part files created during upload in the
same storage as the upload target. Setting this to false will store the part
files in the root of the users folder which might be required to work with certain
external storage setups that have limited rename capabilities.

==== Code Sample

[source,php]
....
'part_file_in_storage' => true,
....

=== mount_file

Where `mount.json` file should be stored, defaults to `data/mount.json`
in the ownCloud directory.

==== Code Sample

[source,php]
....
'mount_file' => '/var/www/owncloud/data/mount.json',
....

=== filesystem_cache_readonly

When `true`, prevent ownCloud from changing the cache due to changes in the
filesystem for all storage.

==== Code Sample

[source,php]
....
'filesystem_cache_readonly' => false,
....

=== secret

Secret used by ownCloud for various purposes, e.g., to encrypt data. If you
lose this string there will be data corruption.

==== Code Sample

[source,php]
....
'secret' => '',
....

=== trusted_proxies

List of trusted proxy servers

If you configure these also consider setting `forwarded_for_headers` which
otherwise defaults to `HTTP_X_FORWARDED_FOR` (the `X-Forwarded-For` header).

==== Code Sample

[source,php]
....
'trusted_proxies' => [
    '203.0.113.45',
    '198.51.100.128'
],
....

=== forwarded_for_headers

Headers that should be trusted as client IP address in combination with
`trusted_proxies`. If the HTTP header looks like `X-Forwarded-For`, then use
`HTTP_X_FORWARDED_FOR` here.

If set incorrectly, a client can spoof their IP address as visible to
ownCloud, bypassing access controls and making logs useless!

Defaults to `HTTP_X_FORWARDED_FOR` if unset

==== Code Sample

[source,php]
....
'forwarded_for_headers' => [
    'HTTP_X_FORWARDED',
    'HTTP_FORWARDED_FOR'
],
....

=== max_filesize_animated_gifs_public_sharing

max file size for animating gifs on public-sharing-site.
If the gif is bigger, it'll show a static preview.

Value represents the maximum file size in megabytes. Default is `10`.
Set to `-1` for no limit.

==== Code Sample

[source,php]
....
'max_filesize_animated_gifs_public_sharing' => 10,
....

=== filelocking.enabled

Enables transactional file locking.
This is enabled by default.

Prevents concurrent processes from accessing the same files
at the same time. Can help prevent side effects that would
be caused by concurrent operations. Mainly relevant for
very large installations with many users working with
shared files.

==== Code Sample

[source,php]
....
'filelocking.enabled' => true,
....

=== filelocking.ttl

Set the lock's time-to-live in seconds.
Any lock older than this will be automatically cleaned up.
If not set this defaults to either 1 hour or the php max_execution_time, whichever is higher.

==== Code Sample

[source,php]
....
'filelocking.ttl' => 3600,
....

=== memcache.locking

Memory caching backend for file locking.
Because most memcache backends can clean values without warning using Redis
is highly recommended to *avoid data loss*.

==== Code Sample

[source,php]
....
'memcache.locking' => '\\\\OC\\\\Memcache\\\\Redis',
....

=== upgrade.disable-web

Disable the web based updater.

==== Code Sample

[source,php]
....
'upgrade.disable-web' => false,
....

=== upgrade.automatic-app-update

Automatic update of market apps, set to `false` to disable.

==== Code Sample

[source,php]
....
'upgrade.automatic-app-update' => true,
....

=== debug

Set this ownCloud instance to debugging mode

Only enable this for local development and not in production environments.
This will disable the minifier and outputs some additional debug information.

WARNING: Be warned that, if you set this to `true`, exceptions display
   stack traces on the web interface, *including passwords*, — **in plain text!**.
   We strongly encourage you never to use it in production.

==== Code Sample

[source,php]
....
'debug' => false,
....

=== data-fingerprint

Sets the data-fingerprint of the current data served.

This is a property used by the clients to find out if a backup has been
restored on the server. Once a backup is restored run `./occ maintenance:data-fingerprint`
to set this to a new value.

Updating/Deleting this value can make connected clients stall until
the user has resolved conflicts.

==== Code Sample

[source,php]
....
'data-fingerprint' => '',
....

=== copied_sample_config

This entry is just here to show a warning in case somebody copied the sample
configuration. DO NOT ADD THIS SWITCH TO YOUR CONFIGURATION!

If you, brave person, have read until here be aware that you should not
modify *ANY* settings in this file without reading the documentation.

==== Code Sample

[source,php]
....
'copied_sample_config' => true,
....

=== files_external_allow_create_new_local

Set this property to true if you want to enable the files_external local mount Option.
Default: false.

==== Code Sample

[source,php]
....
'files_external_allow_create_new_local' => false,
....

=== smb.logging.enable

Set this property to true if you want to enable debug logging for SMB access.

==== Code Sample

[source,php]
....
'smb.logging.enable' => false,
....

",12032,False,2246.08366607196,median
"// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include ""src/compiler/verifier.h""

#include <algorithm>
#include <deque>
#include <queue>
#include <sstream>
#include <string>

#include ""src/bit-vector.h""
#include ""src/compiler/all-nodes.h""
#include ""src/compiler/common-operator.h""
#include ""src/compiler/graph.h""
#include ""src/compiler/js-operator.h""
#include ""src/compiler/node-properties.h""
#include ""src/compiler/node.h""
#include ""src/compiler/opcodes.h""
#include ""src/compiler/operator-properties.h""
#include ""src/compiler/operator.h""
#include ""src/compiler/schedule.h""
#include ""src/compiler/simplified-operator.h""
#include ""src/ostreams.h""

namespace v8 {
namespace internal {
namespace compiler {


class Verifier::Visitor {
 public:
  Visitor(Zone* z, Typing typed, CheckInputs check_inputs)
      : zone(z), typing(typed), check_inputs(check_inputs) {}

  void Check(Node* node);

  Zone* zone;
  Typing typing;
  CheckInputs check_inputs;

 private:
  void CheckNotTyped(Node* node) {
    if (NodeProperties::IsTyped(node)) {
      std::ostringstream str;
      str << ""TypeError: node #"" << node->id() << "":"" << *node->op()
          << "" should never have a type"";
      FATAL(str.str().c_str());
    }
  }
  void CheckTypeIs(Node* node, Type* type) {
    if (typing == TYPED && !NodeProperties::GetType(node)->Is(type)) {
      std::ostringstream str;
      str << ""TypeError: node #"" << node->id() << "":"" << *node->op()
          << "" type "";
      NodeProperties::GetType(node)->PrintTo(str);
      str << "" is not "";
      type->PrintTo(str);
      FATAL(str.str().c_str());
    }
  }
  void CheckTypeMaybe(Node* node, Type* type) {
    if (typing == TYPED && !NodeProperties::GetType(node)->Maybe(type)) {
      std::ostringstream str;
      str << ""TypeError: node #"" << node->id() << "":"" << *node->op()
          << "" type "";
      NodeProperties::GetType(node)->PrintTo(str);
      str << "" must intersect "";
      type->PrintTo(str);
      FATAL(str.str().c_str());
    }
  }
  void CheckValueInputIs(Node* node, int i, Type* type) {
    Node* input = NodeProperties::GetValueInput(node, i);
    if (typing == TYPED && !NodeProperties::GetType(input)->Is(type)) {
      std::ostringstream str;
      str << ""TypeError: node #"" << node->id() << "":"" << *node->op()
          << ""(input @"" << i << "" = "" << input->opcode() << "":""
          << input->op()->mnemonic() << "") type "";
      NodeProperties::GetType(input)->PrintTo(str);
      str << "" is not "";
      type->PrintTo(str);
      FATAL(str.str().c_str());
    }
  }
  void CheckOutput(Node* node, Node* use, int count, const char* kind) {
    if (count <= 0) {
      std::ostringstream str;
      str << ""GraphError: node #"" << node->id() << "":"" << *node->op()
          << "" does not produce "" << kind << "" output used by node #""
          << use->id() << "":"" << *use->op();
      FATAL(str.str().c_str());
    }
  }
};


void Verifier::Visitor::Check(Node* node) {
  int value_count = node->op()->ValueInputCount();
  int context_count = OperatorProperties::GetContextInputCount(node->op());
  int frame_state_count =
      OperatorProperties::GetFrameStateInputCount(node->op());
  int effect_count = node->op()->EffectInputCount();
  int control_count = node->op()->ControlInputCount();

  // Verify number of inputs matches up.
  int input_count = value_count + context_count + frame_state_count;
  if (check_inputs == kAll) {
    input_count += effect_count + control_count;
  }
  CHECK_EQ(input_count, node->InputCount());

  // Verify that frame state has been inserted for the nodes that need it.
  for (int i = 0; i < frame_state_count; i++) {
    Node* frame_state = NodeProperties::GetFrameStateInput(node);
    CHECK(frame_state->opcode() == IrOpcode::kFrameState ||
          // kFrameState uses Start as a sentinel.
          (node->opcode() == IrOpcode::kFrameState &&
           frame_state->opcode() == IrOpcode::kStart));
  }

  // Verify all value inputs actually produce a value.
  for (int i = 0; i < value_count; ++i) {
    Node* value = NodeProperties::GetValueInput(node, i);
    CheckOutput(value, node, value->op()->ValueOutputCount(), ""value"");
    // Verify that only parameters and projections can have input nodes with
    // multiple outputs.
    CHECK(node->opcode() == IrOpcode::kParameter ||
          node->opcode() == IrOpcode::kProjection ||
          value->op()->ValueOutputCount() <= 1);
  }

  // Verify all context inputs are value nodes.
  for (int i = 0; i < context_count; ++i) {
    Node* context = NodeProperties::GetContextInput(node);
    CheckOutput(context, node, context->op()->ValueOutputCount(), ""context"");
  }

  if (check_inputs == kAll) {
    // Verify all effect inputs actually have an effect.
    for (int i = 0; i < effect_count; ++i) {
      Node* effect = NodeProperties::GetEffectInput(node);
      CheckOutput(effect, node, effect->op()->EffectOutputCount(), ""effect"");
    }

    // Verify all control inputs are control nodes.
    for (int i = 0; i < control_count; ++i) {
      Node* control = NodeProperties::GetControlInput(node, i);
      CheckOutput(control, node, control->op()->ControlOutputCount(),
                  ""control"");
    }

    // Verify that no-no-throw nodes only have IfSuccess/IfException control
    // uses.
    if (!node->op()->HasProperty(Operator::kNoThrow)) {
      int count_success = 0, count_exception = 0;
      for (Edge edge : node->use_edges()) {
        if (!NodeProperties::IsControlEdge(edge)) {
          continue;
        }
        Node* control_use = edge.from();
        if (control_use->opcode() != IrOpcode::kIfSuccess &&
            control_use->opcode() != IrOpcode::kIfException) {
          V8_Fatal(__FILE__, __LINE__,
                   ""#%d:%s should be followed by IfSuccess/IfException, but is ""
                   ""followed by #%d:%s"",
                   node->id(), node->op()->mnemonic(), control_use->id(),
                   control_use->op()->mnemonic());
        }
        if (control_use->opcode() == IrOpcode::kIfSuccess) ++count_success;
        if (control_use->opcode() == IrOpcode::kIfException) ++count_exception;
        CHECK_LE(count_success, 1);
        CHECK_LE(count_exception, 1);
      }
    }
  }

  switch (node->opcode()) {
    case IrOpcode::kStart:
      // Start has no inputs.
      CHECK_EQ(0, input_count);
      // Type is a tuple.
      // TODO(rossberg): Multiple outputs are currently typed as Internal.
      CheckTypeIs(node, Type::Internal());
      break;
    case IrOpcode::kEnd:
      // End has no outputs.
      CHECK(node->op()->ValueOutputCount() == 0);
      CHECK(node->op()->EffectOutputCount() == 0);
      CHECK(node->op()->ControlOutputCount() == 0);
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kDead:
      // Dead is never connected to the graph.
      UNREACHABLE();
      break;
    case IrOpcode::kBranch: {
      // Branch uses are IfTrue and IfFalse.
      int count_true = 0, count_false = 0;
      for (const Node* use : node->uses()) {
        CHECK(use->opcode() == IrOpcode::kIfTrue ||
              use->opcode() == IrOpcode::kIfFalse);
        if (use->opcode() == IrOpcode::kIfTrue) ++count_true;
        if (use->opcode() == IrOpcode::kIfFalse) ++count_false;
      }
      CHECK_EQ(1, count_true);
      CHECK_EQ(1, count_false);
      // Type is empty.
      CheckNotTyped(node);
      break;
    }
    case IrOpcode::kIfTrue:
    case IrOpcode::kIfFalse:
      CHECK_EQ(IrOpcode::kBranch,
               NodeProperties::GetControlInput(node, 0)->opcode());
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kIfSuccess: {
      // IfSuccess and IfException continuation only on throwing nodes.
      Node* input = NodeProperties::GetControlInput(node, 0);
      CHECK(!input->op()->HasProperty(Operator::kNoThrow));
      // Type is empty.
      CheckNotTyped(node);
      break;
    }
    case IrOpcode::kIfException: {
      // IfSuccess and IfException continuation only on throwing nodes.
      Node* input = NodeProperties::GetControlInput(node, 0);
      CHECK(!input->op()->HasProperty(Operator::kNoThrow));
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      break;
    }
    case IrOpcode::kSwitch: {
      // Switch uses are Case and Default.
      int count_case = 0, count_default = 0;
      for (const Node* use : node->uses()) {
        switch (use->opcode()) {
          case IrOpcode::kIfValue: {
            for (const Node* user : node->uses()) {
              if (user != use && user->opcode() == IrOpcode::kIfValue) {
                CHECK_NE(OpParameter<int32_t>(use->op()),
                         OpParameter<int32_t>(user->op()));
              }
            }
            ++count_case;
            break;
          }
          case IrOpcode::kIfDefault: {
            ++count_default;
            break;
          }
          default: {
            V8_Fatal(__FILE__, __LINE__, ""Switch #%d illegally used by #%d:%s"",
                     node->id(), use->id(), use->op()->mnemonic());
            break;
          }
        }
      }
      CHECK_EQ(1, count_default);
      CHECK_EQ(node->op()->ControlOutputCount(), count_case + count_default);
      // Type is empty.
      CheckNotTyped(node);
      break;
    }
    case IrOpcode::kIfValue:
    case IrOpcode::kIfDefault:
      CHECK_EQ(IrOpcode::kSwitch,
               NodeProperties::GetControlInput(node)->opcode());
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kLoop:
    case IrOpcode::kMerge:
      CHECK_EQ(control_count, input_count);
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kDeoptimizeIf:
    case IrOpcode::kDeoptimizeUnless:
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kDeoptimize:
    case IrOpcode::kReturn:
    case IrOpcode::kThrow:
      // Deoptimize, Return and Throw uses are End.
      for (const Node* use : node->uses()) {
        CHECK_EQ(IrOpcode::kEnd, use->opcode());
      }
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kTerminate:
      // Terminates take one loop and effect.
      CHECK_EQ(1, control_count);
      CHECK_EQ(1, effect_count);
      CHECK_EQ(2, input_count);
      CHECK_EQ(IrOpcode::kLoop,
               NodeProperties::GetControlInput(node)->opcode());
      // Terminate uses are End.
      for (const Node* use : node->uses()) {
        CHECK_EQ(IrOpcode::kEnd, use->opcode());
      }
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kOsrNormalEntry:
    case IrOpcode::kOsrLoopEntry:
      // Osr entries take one control and effect.
      CHECK_EQ(1, control_count);
      CHECK_EQ(1, effect_count);
      CHECK_EQ(2, input_count);
      // Type is empty.
      CheckNotTyped(node);
      break;

    // Common operators
    // ----------------
    case IrOpcode::kParameter: {
      // Parameters have the start node as inputs.
      CHECK_EQ(1, input_count);
      // Parameter has an input that produces enough values.
      int const index = ParameterIndexOf(node->op());
      Node* const start = NodeProperties::GetValueInput(node, 0);
      CHECK_EQ(IrOpcode::kStart, start->opcode());
      // Currently, parameter indices start at -1 instead of 0.
      CHECK_LE(-1, index);
      CHECK_LT(index + 1, start->op()->ValueOutputCount());
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      break;
    }
    case IrOpcode::kInt32Constant:  // TODO(turbofan): rename Word32Constant?
    case IrOpcode::kInt64Constant:  // TODO(turbofan): rename Word64Constant?
    case IrOpcode::kFloat32Constant:
    case IrOpcode::kFloat64Constant:
    case IrOpcode::kRelocatableInt32Constant:
    case IrOpcode::kRelocatableInt64Constant:
      // Constants have no inputs.
      CHECK_EQ(0, input_count);
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kNumberConstant:
      // Constants have no inputs.
      CHECK_EQ(0, input_count);
      // Type is a number.
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kHeapConstant:
      // Constants have no inputs.
      CHECK_EQ(0, input_count);
      // Type is anything.
      CheckTypeIs(node, Type::Any());
      break;
    case IrOpcode::kExternalConstant:
    case IrOpcode::kPointerConstant:
      // Constants have no inputs.
      CHECK_EQ(0, input_count);
      // Type is an external pointer.
      CheckTypeIs(node, Type::ExternalPointer());
      break;
    case IrOpcode::kOsrValue:
      // OSR values have a value and a control input.
      CHECK_EQ(1, control_count);
      CHECK_EQ(1, input_count);
      // Type is merged from other values in the graph and could be any.
      CheckTypeIs(node, Type::Any());
      break;
    case IrOpcode::kOsrGuard:
      // OSR values have a value and a control input.
      CHECK_EQ(1, value_count);
      CHECK_EQ(1, effect_count);
      CHECK_EQ(1, control_count);
      switch (OsrGuardTypeOf(node->op())) {
        case OsrGuardType::kUninitialized:
          CheckTypeIs(node, Type::None());
          break;
        case OsrGuardType::kSignedSmall:
          CheckTypeIs(node, Type::SignedSmall());
          break;
        case OsrGuardType::kAny:
          CheckTypeIs(node, Type::Any());
          break;
      }
      break;
    case IrOpcode::kProjection: {
      // Projection has an input that produces enough values.
      int index = static_cast<int>(ProjectionIndexOf(node->op()));
      Node* input = NodeProperties::GetValueInput(node, 0);
      CHECK_GT(input->op()->ValueOutputCount(), index);
      // Type can be anything.
      // TODO(rossberg): Introduce tuple types for this.
      // TODO(titzer): Convince rossberg not to.
      CheckTypeIs(node, Type::Any());
      break;
    }
    case IrOpcode::kSelect: {
      CHECK_EQ(0, effect_count);
      CHECK_EQ(0, control_count);
      CHECK_EQ(3, value_count);
      break;
    }
    case IrOpcode::kPhi: {
      // Phi input count matches parent control node.
      CHECK_EQ(0, effect_count);
      CHECK_EQ(1, control_count);
      Node* control = NodeProperties::GetControlInput(node, 0);
      CHECK_EQ(value_count, control->op()->ControlInputCount());
      CHECK_EQ(input_count, 1 + value_count);
      // Type must be subsumed by all input types.
      // TODO(rossberg): for now at least, narrowing does not really hold.
      /*
      for (int i = 0; i < value_count; ++i) {
        CHECK(type_of(ValueInput(node, i))->Is(type_of(node)));
      }
      */
      break;
    }
    case IrOpcode::kInductionVariablePhi: {
      // This is only a temporary node for the typer.
      UNREACHABLE();
      break;
    }
    case IrOpcode::kEffectPhi: {
      // EffectPhi input count matches parent control node.
      CHECK_EQ(0, value_count);
      CHECK_EQ(1, control_count);
      Node* control = NodeProperties::GetControlInput(node, 0);
      CHECK_EQ(effect_count, control->op()->ControlInputCount());
      CHECK_EQ(input_count, 1 + effect_count);
      break;
    }
    case IrOpcode::kLoopExit: {
      CHECK_EQ(2, control_count);
      Node* loop = NodeProperties::GetControlInput(node, 1);
      CHECK_EQ(IrOpcode::kLoop, loop->opcode());
      break;
    }
    case IrOpcode::kLoopExitValue: {
      CHECK_EQ(1, control_count);
      Node* loop_exit = NodeProperties::GetControlInput(node, 0);
      CHECK_EQ(IrOpcode::kLoopExit, loop_exit->opcode());
      break;
    }
    case IrOpcode::kLoopExitEffect: {
      CHECK_EQ(1, control_count);
      Node* loop_exit = NodeProperties::GetControlInput(node, 0);
      CHECK_EQ(IrOpcode::kLoopExit, loop_exit->opcode());
      break;
    }
    case IrOpcode::kCheckpoint:
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kBeginRegion:
      // TODO(rossberg): what are the constraints on these?
      break;
    case IrOpcode::kFinishRegion: {
      // TODO(rossberg): what are the constraints on these?
      // Type must be subsumed by input type.
      if (typing == TYPED) {
        Node* val = NodeProperties::GetValueInput(node, 0);
        CHECK(NodeProperties::GetType(val)->Is(NodeProperties::GetType(node)));
      }
      break;
    }
    case IrOpcode::kFrameState: {
      // TODO(jarin): what are the constraints on these?
      CHECK_EQ(5, value_count);
      CHECK_EQ(0, control_count);
      CHECK_EQ(0, effect_count);
      CHECK_EQ(6, input_count);
      for (int i = 0; i < 3; ++i) {
        CHECK(NodeProperties::GetValueInput(node, i)->opcode() ==
                  IrOpcode::kStateValues ||
              NodeProperties::GetValueInput(node, i)->opcode() ==
                  IrOpcode::kTypedStateValues);
      }
      break;
    }
    case IrOpcode::kStateValues:
    case IrOpcode::kTypedStateValues:
    case IrOpcode::kObjectState:
    case IrOpcode::kTypedObjectState:
      // TODO(jarin): what are the constraints on these?
      break;
    case IrOpcode::kCall:
      // TODO(rossberg): what are the constraints on these?
      break;
    case IrOpcode::kTailCall:
      // TODO(bmeurer): what are the constraints on these?
      break;

    // JavaScript operators
    // --------------------
    case IrOpcode::kJSEqual:
    case IrOpcode::kJSNotEqual:
    case IrOpcode::kJSStrictEqual:
    case IrOpcode::kJSStrictNotEqual:
    case IrOpcode::kJSLessThan:
    case IrOpcode::kJSGreaterThan:
    case IrOpcode::kJSLessThanOrEqual:
    case IrOpcode::kJSGreaterThanOrEqual:
      // Type is Boolean.
      CheckTypeIs(node, Type::Boolean());
      break;

    case IrOpcode::kJSBitwiseOr:
    case IrOpcode::kJSBitwiseXor:
    case IrOpcode::kJSBitwiseAnd:
    case IrOpcode::kJSShiftLeft:
    case IrOpcode::kJSShiftRight:
    case IrOpcode::kJSShiftRightLogical:
      // Type is 32 bit integral.
      CheckTypeIs(node, Type::Integral32());
      break;
    case IrOpcode::kJSAdd:
      // Type is Number or String.
      CheckTypeIs(node, Type::NumberOrString());
      break;
    case IrOpcode::kJSSubtract:
    case IrOpcode::kJSMultiply:
    case IrOpcode::kJSDivide:
    case IrOpcode::kJSModulus:
      // Type is Number.
      CheckTypeIs(node, Type::Number());
      break;

    case IrOpcode::kJSToBoolean:
      // Type is Boolean.
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kJSToInteger:
      // Type is OrderedNumber.
      CheckTypeIs(node, Type::OrderedNumber());
      break;
    case IrOpcode::kJSToLength:
      // Type is OrderedNumber.
      CheckTypeIs(node, Type::OrderedNumber());
      break;
    case IrOpcode::kJSToName:
      // Type is Name.
      CheckTypeIs(node, Type::Name());
      break;
    case IrOpcode::kJSToNumber:
      // Type is Number.
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kJSToString:
      // Type is String.
      CheckTypeIs(node, Type::String());
      break;
    case IrOpcode::kJSToObject:
      // Type is Receiver.
      CheckTypeIs(node, Type::Receiver());
      break;

    case IrOpcode::kJSCreate:
      // Type is Object.
      CheckTypeIs(node, Type::Object());
      break;
    case IrOpcode::kJSCreateArguments:
      // Type is OtherObject.
      CheckTypeIs(node, Type::OtherObject());
      break;
    case IrOpcode::kJSCreateArray:
      // Type is OtherObject.
      CheckTypeIs(node, Type::OtherObject());
      break;
    case IrOpcode::kJSCreateClosure:
      // Type is Function.
      CheckTypeIs(node, Type::Function());
      break;
    case IrOpcode::kJSCreateIterResultObject:
      // Type is OtherObject.
      CheckTypeIs(node, Type::OtherObject());
      break;
    case IrOpcode::kJSCreateKeyValueArray:
      // Type is OtherObject.
      CheckTypeIs(node, Type::OtherObject());
      break;
    case IrOpcode::kJSCreateLiteralArray:
    case IrOpcode::kJSCreateLiteralObject:
    case IrOpcode::kJSCreateLiteralRegExp:
      // Type is OtherObject.
      CheckTypeIs(node, Type::OtherObject());
      break;
    case IrOpcode::kJSLoadProperty:
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      CHECK(PropertyAccessOf(node->op()).feedback().IsValid());
      break;
    case IrOpcode::kJSLoadNamed:
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      CHECK(NamedAccessOf(node->op()).feedback().IsValid());
      break;
    case IrOpcode::kJSLoadGlobal:
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      CHECK(LoadGlobalParametersOf(node->op()).feedback().IsValid());
      break;
    case IrOpcode::kJSStoreProperty:
      // Type is empty.
      CheckNotTyped(node);
      CHECK(PropertyAccessOf(node->op()).feedback().IsValid());
      break;
    case IrOpcode::kJSStoreNamed:
      // Type is empty.
      CheckNotTyped(node);
      CHECK(NamedAccessOf(node->op()).feedback().IsValid());
      break;
    case IrOpcode::kJSStoreGlobal:
      // Type is empty.
      CheckNotTyped(node);
      CHECK(StoreGlobalParametersOf(node->op()).feedback().IsValid());
      break;
    case IrOpcode::kJSStoreDataPropertyInLiteral:
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kJSDeleteProperty:
    case IrOpcode::kJSHasProperty:
    case IrOpcode::kJSInstanceOf:
    case IrOpcode::kJSOrdinaryHasInstance:
      // Type is Boolean.
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kJSTypeOf:
      // Type is String.
      CheckTypeIs(node, Type::String());
      break;

    case IrOpcode::kJSLoadContext:
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      break;
    case IrOpcode::kJSStoreContext:
      // Type is empty.
      CheckNotTyped(node);
      break;
    case IrOpcode::kJSCreateFunctionContext:
    case IrOpcode::kJSCreateCatchContext:
    case IrOpcode::kJSCreateWithContext:
    case IrOpcode::kJSCreateBlockContext:
    case IrOpcode::kJSCreateScriptContext: {
      // Type is Context, and operand is Internal.
      Node* context = NodeProperties::GetContextInput(node);
      // TODO(bmeurer): This should say CheckTypeIs, but we don't have type
      // OtherInternal on certain contexts, i.e. those from OsrValue inputs.
      CheckTypeMaybe(context, Type::OtherInternal());
      CheckTypeIs(node, Type::OtherInternal());
      break;
    }

    case IrOpcode::kJSCallConstruct:
    case IrOpcode::kJSCallConstructWithSpread:
    case IrOpcode::kJSConvertReceiver:
      // Type is Receiver.
      CheckTypeIs(node, Type::Receiver());
      break;
    case IrOpcode::kJSCallFunction:
    case IrOpcode::kJSCallRuntime:
      // Type can be anything.
      CheckTypeIs(node, Type::Any());
      break;

    case IrOpcode::kJSForInPrepare: {
      // TODO(bmeurer): What are the constraints on thse?
      CheckTypeIs(node, Type::Any());
      break;
    }
    case IrOpcode::kJSForInNext: {
      CheckTypeIs(node, Type::Union(Type::Name(), Type::Undefined(), zone));
      break;
    }

    case IrOpcode::kJSLoadMessage:
    case IrOpcode::kJSStoreMessage:
      break;

    case IrOpcode::kJSLoadModule:
      CheckTypeIs(node, Type::Any());
      break;
    case IrOpcode::kJSStoreModule:
      CheckNotTyped(node);
      break;

    case IrOpcode::kJSGeneratorStore:
      CheckNotTyped(node);
      break;

    case IrOpcode::kJSGeneratorRestoreContinuation:
      CheckTypeIs(node, Type::SignedSmall());
      break;

    case IrOpcode::kJSGeneratorRestoreRegister:
      CheckTypeIs(node, Type::Any());
      break;

    case IrOpcode::kJSStackCheck:
      // Type is empty.
      CheckNotTyped(node);
      break;

    case IrOpcode::kComment:
    case IrOpcode::kDebugBreak:
    case IrOpcode::kRetain:
    case IrOpcode::kUnsafePointerAdd:
      CheckNotTyped(node);
      break;

    // Simplified operators
    // -------------------------------
    case IrOpcode::kBooleanNot:
      // Boolean -> Boolean
      CheckValueInputIs(node, 0, Type::Boolean());
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kNumberEqual:
      // (Number, Number) -> Boolean
      CheckValueInputIs(node, 0, Type::Number());
      CheckValueInputIs(node, 1, Type::Number());
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kNumberLessThan:
    case IrOpcode::kNumberLessThanOrEqual:
      // (Number, Number) -> Boolean
      CheckValueInputIs(node, 0, Type::Number());
      CheckValueInputIs(node, 1, Type::Number());
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kSpeculativeNumberAdd:
    case IrOpcode::kSpeculativeNumberSubtract:
    case IrOpcode::kSpeculativeNumberMultiply:
    case IrOpcode::kSpeculativeNumberDivide:
    case IrOpcode::kSpeculativeNumberModulus:
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kSpeculativeNumberEqual:
    case IrOpcode::kSpeculativeNumberLessThan:
    case IrOpcode::kSpeculativeNumberLessThanOrEqual:
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kNumberAdd:
    case IrOpcode::kNumberSubtract:
    case IrOpcode::kNumberMultiply:
    case IrOpcode::kNumberDivide:
      // (Number, Number) -> Number
      CheckValueInputIs(node, 0, Type::Number());
      CheckValueInputIs(node, 1, Type::Number());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kNumberModulus:
      // (Number, Number) -> Number
      CheckValueInputIs(node, 0, Type::Number());
      CheckValueInputIs(node, 1, Type::Number());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kNumberBitwiseOr:
    case IrOpcode::kNumberBitwiseXor:
    case IrOpcode::kNumberBitwiseAnd:
      // (Signed32, Signed32) -> Signed32
      CheckValueInputIs(node, 0, Type::Signed32());
      CheckValueInputIs(node, 1, Type::Signed32());
      CheckTypeIs(node, Type::Signed32());
      break;
    case IrOpcode::kSpeculativeNumberBitwiseOr:
    case IrOpcode::kSpeculativeNumberBitwiseXor:
    case IrOpcode::kSpeculativeNumberBitwiseAnd:
      CheckTypeIs(node, Type::Signed32());
      break;
    case IrOpcode::kNumberShiftLeft:
    case IrOpcode::kNumberShiftRight:
      // (Signed32, Unsigned32) -> Signed32
      CheckValueInputIs(node, 0, Type::Signed32());
      CheckValueInputIs(node, 1, Type::Unsigned32());
      CheckTypeIs(node, Type::Signed32());
      break;
    case IrOpcode::kSpeculativeNumberShiftLeft:
    case IrOpcode::kSpeculativeNumberShiftRight:
      CheckTypeIs(node, Type::Signed32());
      break;
    case IrOpcode::kNumberShiftRightLogical:
      // (Unsigned32, Unsigned32) -> Unsigned32
      CheckValueInputIs(node, 0, Type::Unsigned32());
      CheckValueInputIs(node, 1, Type::Unsigned32());
      CheckTypeIs(node, Type::Unsigned32());
      break;
    case IrOpcode::kSpeculativeNumberShiftRightLogical:
      CheckTypeIs(node, Type::Unsigned32());
      break;
    case IrOpcode::kNumberImul:
      // (Unsigned32, Unsigned32) -> Signed32
      CheckValueInputIs(node, 0, Type::Unsigned32());
      CheckValueInputIs(node, 1, Type::Unsigned32());
      CheckTypeIs(node, Type::Signed32());
      break;
    case IrOpcode::kNumberClz32:
      // Unsigned32 -> Unsigned32
      CheckValueInputIs(node, 0, Type::Unsigned32());
      CheckTypeIs(node, Type::Unsigned32());
      break;
    case IrOpcode::kNumberAtan2:
    case IrOpcode::kNumberMax:
    case IrOpcode::kNumberMin:
    case IrOpcode::kNumberPow:
      // (Number, Number) -> Number
      CheckValueInputIs(node, 0, Type::Number());
      CheckValueInputIs(node, 1, Type::Number());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kNumberAbs:
    case IrOpcode::kNumberCeil:
    case IrOpcode::kNumberFloor:
    case IrOpcode::kNumberFround:
    case IrOpcode::kNumberAcos:
    case IrOpcode::kNumberAcosh:
    case IrOpcode::kNumberAsin:
    case IrOpcode::kNumberAsinh:
    case IrOpcode::kNumberAtan:
    case IrOpcode::kNumberAtanh:
    case IrOpcode::kNumberCos:
    case IrOpcode::kNumberCosh:
    case IrOpcode::kNumberExp:
    case IrOpcode::kNumberExpm1:
    case IrOpcode::kNumberLog:
    case IrOpcode::kNumberLog1p:
    case IrOpcode::kNumberLog2:
    case IrOpcode::kNumberLog10:
    case IrOpcode::kNumberCbrt:
    case IrOpcode::kNumberRound:
    case IrOpcode::kNumberSign:
    case IrOpcode::kNumberSin:
    case IrOpcode::kNumberSinh:
    case IrOpcode::kNumberSqrt:
    case IrOpcode::kNumberTan:
    case IrOpcode::kNumberTanh:
    case IrOpcode::kNumberTrunc:
      // Number -> Number
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kNumberToBoolean:
      // Number -> Boolean
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kNumberToInt32:
      // Number -> Signed32
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::Signed32());
      break;
    case IrOpcode::kNumberToUint32:
    case IrOpcode::kNumberToUint8Clamped:
      // Number -> Unsigned32
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::Unsigned32());
      break;
    case IrOpcode::kPlainPrimitiveToNumber:
      // PlainPrimitive -> Number
      CheckValueInputIs(node, 0, Type::PlainPrimitive());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kPlainPrimitiveToWord32:
      // PlainPrimitive -> Integral32
      CheckValueInputIs(node, 0, Type::PlainPrimitive());
      CheckTypeIs(node, Type::Integral32());
      break;
    case IrOpcode::kPlainPrimitiveToFloat64:
      // PlainPrimitive -> Number
      CheckValueInputIs(node, 0, Type::PlainPrimitive());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kStringEqual:
    case IrOpcode::kStringLessThan:
    case IrOpcode::kStringLessThanOrEqual:
      // (String, String) -> Boolean
      CheckValueInputIs(node, 0, Type::String());
      CheckValueInputIs(node, 1, Type::String());
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kStringCharCodeAt:
      // (String, Unsigned32) -> UnsignedSmall
      CheckValueInputIs(node, 0, Type::String());
      CheckValueInputIs(node, 1, Type::Unsigned32());
      CheckTypeIs(node, Type::UnsignedSmall());
      break;
    case IrOpcode::kStringFromCharCode:
      // Number -> String
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::String());
      break;
    case IrOpcode::kStringFromCodePoint:
      // (Unsigned32) -> String
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::String());
      break;
    case IrOpcode::kReferenceEqual: {
      // (Unique, Any) -> Boolean  and
      // (Any, Unique) -> Boolean
      CheckTypeIs(node, Type::Boolean());
      break;
    }
    case IrOpcode::kObjectIsCallable:
    case IrOpcode::kObjectIsNumber:
    case IrOpcode::kObjectIsReceiver:
    case IrOpcode::kObjectIsSmi:
    case IrOpcode::kObjectIsString:
    case IrOpcode::kObjectIsUndetectable:
    case IrOpcode::kArrayBufferWasNeutered:
      CheckValueInputIs(node, 0, Type::Any());
      CheckTypeIs(node, Type::Boolean());
      break;
    case IrOpcode::kNewRestParameterElements:
    case IrOpcode::kNewUnmappedArgumentsElements:
      CheckTypeIs(node, Type::OtherInternal());
      break;
    case IrOpcode::kAllocate:
      CheckValueInputIs(node, 0, Type::PlainNumber());
      break;
    case IrOpcode::kEnsureWritableFastElements:
      CheckValueInputIs(node, 0, Type::Any());
      CheckValueInputIs(node, 1, Type::Internal());
      CheckTypeIs(node, Type::Internal());
      break;
    case IrOpcode::kMaybeGrowFastElements:
      CheckValueInputIs(node, 0, Type::Any());
      CheckValueInputIs(node, 1, Type::Internal());
      CheckValueInputIs(node, 2, Type::Unsigned31());
      CheckValueInputIs(node, 3, Type::Unsigned31());
      CheckTypeIs(node, Type::Internal());
      break;
    case IrOpcode::kTransitionElementsKind:
      CheckValueInputIs(node, 0, Type::Any());
      CheckValueInputIs(node, 1, Type::Internal());
      CheckValueInputIs(node, 2, Type::Internal());
      CheckNotTyped(node);
      break;

    case IrOpcode::kChangeTaggedSignedToInt32: {
      // Signed32 /\\ Tagged -> Signed32 /\\ UntaggedInt32
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Signed32(), Type::Tagged());
      // Type* to = Type::Intersect(Type::Signed32(), Type::UntaggedInt32());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeTaggedToInt32: {
      // Signed32 /\\ Tagged -> Signed32 /\\ UntaggedInt32
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Signed32(), Type::Tagged());
      // Type* to = Type::Intersect(Type::Signed32(), Type::UntaggedInt32());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeTaggedToUint32: {
      // Unsigned32 /\\ Tagged -> Unsigned32 /\\ UntaggedInt32
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Unsigned32(), Type::Tagged());
      // Type* to =Type::Intersect(Type::Unsigned32(), Type::UntaggedInt32());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeTaggedToFloat64: {
      // NumberOrUndefined /\\ Tagged -> Number /\\ UntaggedFloat64
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Number(), Type::Tagged());
      // Type* to = Type::Intersect(Type::Number(), Type::UntaggedFloat64());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kTruncateTaggedToFloat64: {
      // NumberOrUndefined /\\ Tagged -> Number /\\ UntaggedFloat64
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::NumberOrUndefined(),
      // Type::Tagged());
      // Type* to = Type::Intersect(Type::Number(), Type::UntaggedFloat64());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeInt31ToTaggedSigned: {
      // Signed31 /\\ UntaggedInt32 -> Signed31 /\\ Tagged
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from =Type::Intersect(Type::Signed31(), Type::UntaggedInt32());
      // Type* to = Type::Intersect(Type::Signed31(), Type::Tagged());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeInt32ToTagged: {
      // Signed32 /\\ UntaggedInt32 -> Signed32 /\\ Tagged
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from =Type::Intersect(Type::Signed32(), Type::UntaggedInt32());
      // Type* to = Type::Intersect(Type::Signed32(), Type::Tagged());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeUint32ToTagged: {
      // Unsigned32 /\\ UntaggedInt32 -> Unsigned32 /\\ Tagged
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from=Type::Intersect(Type::Unsigned32(),Type::UntaggedInt32());
      // Type* to = Type::Intersect(Type::Unsigned32(), Type::Tagged());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeFloat64ToTagged: {
      // Number /\\ UntaggedFloat64 -> Number /\\ Tagged
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from =Type::Intersect(Type::Number(), Type::UntaggedFloat64());
      // Type* to = Type::Intersect(Type::Number(), Type::Tagged());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeFloat64ToTaggedPointer:
      break;
    case IrOpcode::kChangeTaggedToBit: {
      // Boolean /\\ TaggedPtr -> Boolean /\\ UntaggedInt1
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Boolean(), Type::TaggedPtr());
      // Type* to = Type::Intersect(Type::Boolean(), Type::UntaggedInt1());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kChangeBitToTagged: {
      // Boolean /\\ UntaggedInt1 -> Boolean /\\ TaggedPtr
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Boolean(), Type::UntaggedInt1());
      // Type* to = Type::Intersect(Type::Boolean(), Type::TaggedPtr());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kTruncateTaggedToWord32: {
      // Number /\\ Tagged -> Signed32 /\\ UntaggedInt32
      // TODO(neis): Activate once ChangeRepresentation works in typer.
      // Type* from = Type::Intersect(Type::Number(), Type::Tagged());
      // Type* to = Type::Intersect(Type::Number(), Type::UntaggedInt32());
      // CheckValueInputIs(node, 0, from));
      // CheckTypeIs(node, to));
      break;
    }
    case IrOpcode::kTruncateTaggedToBit:
      break;

    case IrOpcode::kCheckBounds:
      CheckValueInputIs(node, 0, Type::Any());
      CheckValueInputIs(node, 1, Type::Unsigned31());
      CheckTypeIs(node, Type::Unsigned31());
      break;
    case IrOpcode::kCheckHeapObject:
      CheckValueInputIs(node, 0, Type::Any());
      break;
    case IrOpcode::kCheckIf:
      CheckValueInputIs(node, 0, Type::Boolean());
      CheckNotTyped(node);
      break;
    case IrOpcode::kCheckMaps:
      // (Any, Internal, ..., Internal) -> Any
      CheckValueInputIs(node, 0, Type::Any());
      for (int i = 1; i < node->op()->ValueInputCount(); ++i) {
        CheckValueInputIs(node, i, Type::Internal());
      }
      CheckNotTyped(node);
      break;
    case IrOpcode::kCheckNumber:
      CheckValueInputIs(node, 0, Type::Any());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kCheckSmi:
      CheckValueInputIs(node, 0, Type::Any());
      break;
    case IrOpcode::kCheckString:
      CheckValueInputIs(node, 0, Type::Any());
      CheckTypeIs(node, Type::String());
      break;

    case IrOpcode::kCheckedInt32Add:
    case IrOpcode::kCheckedInt32Sub:
    case IrOpcode::kCheckedInt32Div:
    case IrOpcode::kCheckedInt32Mod:
    case IrOpcode::kCheckedUint32Div:
    case IrOpcode::kCheckedUint32Mod:
    case IrOpcode::kCheckedInt32Mul:
    case IrOpcode::kCheckedInt32ToTaggedSigned:
    case IrOpcode::kCheckedUint32ToInt32:
    case IrOpcode::kCheckedUint32ToTaggedSigned:
    case IrOpcode::kCheckedFloat64ToInt32:
    case IrOpcode::kCheckedTaggedSignedToInt32:
    case IrOpcode::kCheckedTaggedToInt32:
    case IrOpcode::kCheckedTaggedToFloat64:
    case IrOpcode::kCheckedTaggedToTaggedSigned:
    case IrOpcode::kCheckedTaggedToTaggedPointer:
    case IrOpcode::kCheckedTruncateTaggedToWord32:
      break;

    case IrOpcode::kCheckFloat64Hole:
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kCheckTaggedHole:
      CheckValueInputIs(node, 0, Type::Any());
      CheckTypeIs(node, Type::NonInternal());
      break;
    case IrOpcode::kConvertTaggedHoleToUndefined:
      CheckValueInputIs(node, 0, Type::Any());
      CheckTypeIs(node, Type::NonInternal());
      break;

    case IrOpcode::kLoadField:
      // Object -> fieldtype
      // TODO(rossberg): activate once machine ops are typed.
      // CheckValueInputIs(node, 0, Type::Object());
      // CheckTypeIs(node, FieldAccessOf(node->op()).type));
      break;
    case IrOpcode::kLoadBuffer:
      break;
    case IrOpcode::kLoadElement:
      // Object -> elementtype
      // TODO(rossberg): activate once machine ops are typed.
      // CheckValueInputIs(node, 0, Type::Object());
      // CheckTypeIs(node, ElementAccessOf(node->op()).type));
      break;
    case IrOpcode::kLoadTypedElement:
      break;
    case IrOpcode::kStoreField:
      // (Object, fieldtype) -> _|_
      // TODO(rossberg): activate once machine ops are typed.
      // CheckValueInputIs(node, 0, Type::Object());
      // CheckValueInputIs(node, 1, FieldAccessOf(node->op()).type));
      CheckNotTyped(node);
      break;
    case IrOpcode::kStoreBuffer:
      break;
    case IrOpcode::kStoreElement:
      // (Object, elementtype) -> _|_
      // TODO(rossberg): activate once machine ops are typed.
      // CheckValueInputIs(node, 0, Type::Object());
      // CheckValueInputIs(node, 1, ElementAccessOf(node->op()).type));
      CheckNotTyped(node);
      break;
    case IrOpcode::kStoreTypedElement:
      CheckNotTyped(node);
      break;
    case IrOpcode::kNumberSilenceNaN:
      CheckValueInputIs(node, 0, Type::Number());
      CheckTypeIs(node, Type::Number());
      break;
    case IrOpcode::kTypeGuard:
      CheckTypeIs(node, TypeGuardTypeOf(node->op()));
      break;

    // Machine operators
    // -----------------------
    case IrOpcode::kLoad:
    case IrOpcode::kProtectedLoad:
    case IrOpcode::kProtectedStore:
    case IrOpcode::kStore:
    case IrOpcode::kStackSlot:
    case IrOpcode::kWord32And:
    case IrOpcode::kWord32Or:
    case IrOpcode::kWord32Xor:
    case IrOpcode::kWord32Shl:
    case IrOpcode::kWord32Shr:
    case IrOpcode::kWord32Sar:
    case IrOpcode::kWord32Ror:
    case IrOpcode::kWord32Equal:
    case IrOpcode::kWord32Clz:
    case IrOpcode::kWord32Ctz:
    case IrOpcode::kWord32ReverseBits:
    case IrOpcode::kWord32ReverseBytes:
    case IrOpcode::kWord32Popcnt:
    case IrOpcode::kWord64And:
    case IrOpcode::kWord64Or:
    case IrOpcode::kWord64Xor:
    case IrOpcode::kWord64Shl:
    case IrOpcode::kWord64Shr:
    case IrOpcode::kWord64Sar:
    case IrOpcode::kWord64Ror:
    case IrOpcode::kWord64Clz:
    case IrOpcode::kWord64Popcnt:
    case IrOpcode::kWord64Ctz:
    case IrOpcode::kWord64ReverseBits:
    case IrOpcode::kWord64ReverseBytes:
    case IrOpcode::kWord64Equal:
    case IrOpcode::kInt32Add:
    case IrOpcode::kInt32AddWithOverflow:
    case IrOpcode::kInt32Sub:
    case IrOpcode::kInt32SubWithOverflow:
    case IrOpcode::kInt32Mul:
    case IrOpcode::kInt32MulWithOverflow:
    case IrOpcode::kInt32MulHigh:
    case IrOpcode::kInt32Div:
    case IrOpcode::kInt32Mod:
    case IrOpcode::kInt32LessThan:
    case IrOpcode::kInt32LessThanOrEqual:
    case IrOpcode::kUint32Div:
    case IrOpcode::kUint32Mod:
    case IrOpcode::kUint32MulHigh:
    case IrOpcode::kUint32LessThan:
    case IrOpcode::kUint32LessThanOrEqual:
    case IrOpcode::kInt64Add:
    case IrOpcode::kInt64AddWithOverflow:
    case IrOpcode::kInt64Sub:
    case IrOpcode::kInt64SubWithOverflow:
    case IrOpcode::kInt64Mul:
    case IrOpcode::kInt64Div:
    case IrOpcode::kInt64Mod:
    case IrOpcode::kInt64LessThan:
    case IrOpcode::kInt64LessThanOrEqual:
    case IrOpcode::kUint64Div:
    case IrOpcode::kUint64Mod:
    case IrOpcode::kUint64LessThan:
    case IrOpcode::kUint64LessThanOrEqual:
    case IrOpcode::kFloat32Add:
    case IrOpcode::kFloat32Sub:
    case IrOpcode::kFloat32Neg:
    case IrOpcode::kFloat32Mul:
    case IrOpcode::kFloat32Div:
    case IrOpcode::kFloat32Abs:
    case IrOpcode::kFloat32Sqrt:
    case IrOpcode::kFloat32Equal:
    case IrOpcode::kFloat32LessThan:
    case IrOpcode::kFloat32LessThanOrEqual:
    case IrOpcode::kFloat32Max:
    case IrOpcode::kFloat32Min:
    case IrOpcode::kFloat64Add:
    case IrOpcode::kFloat64Sub:
    case IrOpcode::kFloat64Neg:
    case IrOpcode::kFloat64Mul:
    case IrOpcode::kFloat64Div:
    case IrOpcode::kFloat64Mod:
    case IrOpcode::kFloat64Max:
    case IrOpcode::kFloat64Min:
    case IrOpcode::kFloat64Abs:
    case IrOpcode::kFloat64Acos:
    case IrOpcode::kFloat64Acosh:
    case IrOpcode::kFloat64Asin:
    case IrOpcode::kFloat64Asinh:
    case IrOpcode::kFloat64Atan:
    case IrOpcode::kFloat64Atan2:
    case IrOpcode::kFloat64Atanh:
    case IrOpcode::kFloat64Cbrt:
    case IrOpcode::kFloat64Cos:
    case IrOpcode::kFloat64Cosh:
    case IrOpcode::kFloat64Exp:
    case IrOpcode::kFloat64Expm1:
    case IrOpcode::kFloat64Log:
    case IrOpcode::kFloat64Log1p:
    case IrOpcode::kFloat64Log10:
    case IrOpcode::kFloat64Log2:
    case IrOpcode::kFloat64Pow:
    case IrOpcode::kFloat64Sin:
    case IrOpcode::kFloat64Sinh:
    case IrOpcode::kFloat64Sqrt:
    case IrOpcode::kFloat64Tan:
    case IrOpcode::kFloat64Tanh:
    case IrOpcode::kFloat32RoundDown:
    case IrOpcode::kFloat64RoundDown:
    case IrOpcode::kFloat32RoundUp:
    case IrOpcode::kFloat64RoundUp:
    case IrOpcode::kFloat32RoundTruncate:
    case IrOpcode::kFloat64RoundTruncate:
    case IrOpcode::kFloat64RoundTiesAway:
    case IrOpcode::kFloat32RoundTiesEven:
    case IrOpcode::kFloat64RoundTiesEven:
    case IrOpcode::kFloat64Equal:
    case IrOpcode::kFloat64LessThan:
    case IrOpcode::kFloat64LessThanOrEqual:
    case IrOpcode::kTruncateInt64ToInt32:
    case IrOpcode::kRoundFloat64ToInt32:
    case IrOpcode::kRoundInt32ToFloat32:
    case IrOpcode::kRoundInt64ToFloat32:
    case IrOpcode::kRoundInt64ToFloat64:
    case IrOpcode::kRoundUint32ToFloat32:
    case IrOpcode::kRoundUint64ToFloat64:
    case IrOpcode::kRoundUint64ToFloat32:
    case IrOpcode::kTruncateFloat64ToFloat32:
    case IrOpcode::kTruncateFloat64ToWord32:
    case IrOpcode::kBitcastFloat32ToInt32:
    case IrOpcode::kBitcastFloat64ToInt64:
    case IrOpcode::kBitcastInt32ToFloat32:
    case IrOpcode::kBitcastInt64ToFloat64:
    case IrOpcode::kBitcastTaggedToWord:
    case IrOpcode::kBitcastWordToTagged:
    case IrOpcode::kBitcastWordToTaggedSigned:
    case IrOpcode::kChangeInt32ToInt64:
    case IrOpcode::kChangeUint32ToUint64:
    case IrOpcode::kChangeInt32ToFloat64:
    case IrOpcode::kChangeUint32ToFloat64:
    case IrOpcode::kChangeFloat32ToFloat64:
    case IrOpcode::kChangeFloat64ToInt32:
    case IrOpcode::kChangeFloat64ToUint32:
    case IrOpcode::kFloat64SilenceNaN:
    case IrOpcode::kTruncateFloat64ToUint32:
    case IrOpcode::kTruncateFloat32ToInt32:
    case IrOpcode::kTruncateFloat32ToUint32:
    case IrOpcode::kTryTruncateFloat32ToInt64:
    case IrOpcode::kTryTruncateFloat64ToInt64:
    case IrOpcode::kTryTruncateFloat32ToUint64:
    case IrOpcode::kTryTruncateFloat64ToUint64:
    case IrOpcode::kFloat64ExtractLowWord32:
    case IrOpcode::kFloat64ExtractHighWord32:
    case IrOpcode::kFloat64InsertLowWord32:
    case IrOpcode::kFloat64InsertHighWord32:
    case IrOpcode::kInt32PairAdd:
    case IrOpcode::kInt32PairSub:
    case IrOpcode::kInt32PairMul:
    case IrOpcode::kWord32PairShl:
    case IrOpcode::kWord32PairShr:
    case IrOpcode::kWord32PairSar:
    case IrOpcode::kLoadStackPointer:
    case IrOpcode::kLoadFramePointer:
    case IrOpcode::kLoadParentFramePointer:
    case IrOpcode::kUnalignedLoad:
    case IrOpcode::kUnalignedStore:
    case IrOpcode::kCheckedLoad:
    case IrOpcode::kCheckedStore:
    case IrOpcode::kAtomicLoad:
    case IrOpcode::kAtomicStore:

#define SIMD_MACHINE_OP_CASE(Name) case IrOpcode::k##Name:
      MACHINE_SIMD_OP_LIST(SIMD_MACHINE_OP_CASE)
#undef SIMD_MACHINE_OP_CASE

      // TODO(rossberg): Check.
      break;
  }
}  // NOLINT(readability/fn_size)

void Verifier::Run(Graph* graph, Typing typing, CheckInputs check_inputs) {
  CHECK_NOT_NULL(graph->start());
  CHECK_NOT_NULL(graph->end());
  Zone zone(graph->zone()->allocator(), ZONE_NAME);
  Visitor visitor(&zone, typing, check_inputs);
  AllNodes all(&zone, graph);
  for (Node* node : all.reachable) visitor.Check(node);

  // Check the uniqueness of projections.
  for (Node* proj : all.reachable) {
    if (proj->opcode() != IrOpcode::kProjection) continue;
    Node* node = proj->InputAt(0);
    for (Node* other : node->uses()) {
      if (all.IsLive(other) && other != proj &&
          other->opcode() == IrOpcode::kProjection &&
          ProjectionIndexOf(other->op()) == ProjectionIndexOf(proj->op())) {
        V8_Fatal(__FILE__, __LINE__,
                 ""Node #%d:%s has duplicate projections #%d and #%d"",
                 node->id(), node->op()->mnemonic(), proj->id(), other->id());
      }
    }
  }
}


// -----------------------------------------------------------------------------

static bool HasDominatingDef(Schedule* schedule, Node* node,
                             BasicBlock* container, BasicBlock* use_block,
                             int use_pos) {
  BasicBlock* block = use_block;
  while (true) {
    while (use_pos >= 0) {
      if (block->NodeAt(use_pos) == node) return true;
      use_pos--;
    }
    block = block->dominator();
    if (block == nullptr) break;
    use_pos = static_cast<int>(block->NodeCount()) - 1;
    if (node == block->control_input()) return true;
  }
  return false;
}


static bool Dominates(Schedule* schedule, Node* dominator, Node* dominatee) {
  BasicBlock* dom = schedule->block(dominator);
  BasicBlock* sub = schedule->block(dominatee);
  while (sub != nullptr) {
    if (sub == dom) {
      return true;
    }
    sub = sub->dominator();
  }
  return false;
}


static void CheckInputsDominate(Schedule* schedule, BasicBlock* block,
                                Node* node, int use_pos) {
  for (int j = node->op()->ValueInputCount() - 1; j >= 0; j--) {
    BasicBlock* use_block = block;
    if (node->opcode() == IrOpcode::kPhi) {
      use_block = use_block->PredecessorAt(j);
      use_pos = static_cast<int>(use_block->NodeCount()) - 1;
    }
    Node* input = node->InputAt(j);
    if (!HasDominatingDef(schedule, node->InputAt(j), block, use_block,
                          use_pos)) {
      V8_Fatal(__FILE__, __LINE__,
               ""Node #%d:%s in B%d is not dominated by input@%d #%d:%s"",
               node->id(), node->op()->mnemonic(), block->rpo_number(), j,
               input->id(), input->op()->mnemonic());
    }
  }
  // Ensure that nodes are dominated by their control inputs;
  // kEnd is an exception, as unreachable blocks resulting from kMerge
  // are not in the RPO.
  if (node->op()->ControlInputCount() == 1 &&
      node->opcode() != IrOpcode::kEnd) {
    Node* ctl = NodeProperties::GetControlInput(node);
    if (!Dominates(schedule, ctl, node)) {
      V8_Fatal(__FILE__, __LINE__,
               ""Node #%d:%s in B%d is not dominated by control input #%d:%s"",
               node->id(), node->op()->mnemonic(), block->rpo_number(),
               ctl->id(), ctl->op()->mnemonic());
    }
  }
}


void ScheduleVerifier::Run(Schedule* schedule) {
  const size_t count = schedule->BasicBlockCount();
  Zone tmp_zone(schedule->zone()->allocator(), ZONE_NAME);
  Zone* zone = &tmp_zone;
  BasicBlock* start = schedule->start();
  BasicBlockVector* rpo_order = schedule->rpo_order();

  // Verify the RPO order contains only blocks from this schedule.
  CHECK_GE(count, rpo_order->size());
  for (BasicBlockVector::iterator b = rpo_order->begin(); b != rpo_order->end();
       ++b) {
    CHECK_EQ((*b), schedule->GetBlockById((*b)->id()));
    // All predecessors and successors should be in rpo and in this schedule.
    for (BasicBlock const* predecessor : (*b)->predecessors()) {
      CHECK_GE(predecessor->rpo_number(), 0);
      CHECK_EQ(predecessor, schedule->GetBlockById(predecessor->id()));
    }
    for (BasicBlock const* successor : (*b)->successors()) {
      CHECK_GE(successor->rpo_number(), 0);
      CHECK_EQ(successor, schedule->GetBlockById(successor->id()));
    }
  }

  // Verify RPO numbers of blocks.
  CHECK_EQ(start, rpo_order->at(0));  // Start should be first.
  for (size_t b = 0; b < rpo_order->size(); b++) {
    BasicBlock* block = rpo_order->at(b);
    CHECK_EQ(static_cast<int>(b), block->rpo_number());
    BasicBlock* dom = block->dominator();
    if (b == 0) {
      // All blocks except start should have a dominator.
      CHECK_NULL(dom);
    } else {
      // Check that the immediate dominator appears somewhere before the block.
      CHECK_NOT_NULL(dom);
      CHECK_LT(dom->rpo_number(), block->rpo_number());
    }
  }

  // Verify that all blocks reachable from start are in the RPO.
  BoolVector marked(static_cast<int>(count), false, zone);
  {
    ZoneQueue<BasicBlock*> queue(zone);
    queue.push(start);
    marked[start->id().ToSize()] = true;
    while (!queue.empty()) {
      BasicBlock* block = queue.front();
      queue.pop();
      for (size_t s = 0; s < block->SuccessorCount(); s++) {
        BasicBlock* succ = block->SuccessorAt(s);
        if (!marked[succ->id().ToSize()]) {
          marked[succ->id().ToSize()] = true;
          queue.push(succ);
        }
      }
    }
  }
  // Verify marked blocks are in the RPO.
  for (size_t i = 0; i < count; i++) {
    BasicBlock* block = schedule->GetBlockById(BasicBlock::Id::FromSize(i));
    if (marked[i]) {
      CHECK_GE(block->rpo_number(), 0);
      CHECK_EQ(block, rpo_order->at(block->rpo_number()));
    }
  }
  // Verify RPO blocks are marked.
  for (size_t b = 0; b < rpo_order->size(); b++) {
    CHECK(marked[rpo_order->at(b)->id().ToSize()]);
  }

  {
    // Verify the dominance relation.
    ZoneVector<BitVector*> dominators(zone);
    dominators.resize(count, nullptr);

    // Compute a set of all the nodes that dominate a given node by using
    // a forward fixpoint. O(n^2).
    ZoneQueue<BasicBlock*> queue(zone);
    queue.push(start);
    dominators[start->id().ToSize()] =
        new (zone) BitVector(static_cast<int>(count), zone);
    while (!queue.empty()) {
      BasicBlock* block = queue.front();
      queue.pop();
      BitVector* block_doms = dominators[block->id().ToSize()];
      BasicBlock* idom = block->dominator();
      if (idom != nullptr && !block_doms->Contains(idom->id().ToInt())) {
        V8_Fatal(__FILE__, __LINE__, ""Block B%d is not dominated by B%d"",
                 block->rpo_number(), idom->rpo_number());
      }
      for (size_t s = 0; s < block->SuccessorCount(); s++) {
        BasicBlock* succ = block->SuccessorAt(s);
        BitVector* succ_doms = dominators[succ->id().ToSize()];

        if (succ_doms == nullptr) {
          // First time visiting the node. S.doms = B U B.doms
          succ_doms = new (zone) BitVector(static_cast<int>(count), zone);
          succ_doms->CopyFrom(*block_doms);
          succ_doms->Add(block->id().ToInt());
          dominators[succ->id().ToSize()] = succ_doms;
          queue.push(succ);
        } else {
          // Nth time visiting the successor. S.doms = S.doms ^ (B U B.doms)
          bool had = succ_doms->Contains(block->id().ToInt());
          if (had) succ_doms->Remove(block->id().ToInt());
          if (succ_doms->IntersectIsChanged(*block_doms)) queue.push(succ);
          if (had) succ_doms->Add(block->id().ToInt());
        }
      }
    }

    // Verify the immediateness of dominators.
    for (BasicBlockVector::iterator b = rpo_order->begin();
         b != rpo_order->end(); ++b) {
      BasicBlock* block = *b;
      BasicBlock* idom = block->dominator();
      if (idom == nullptr) continue;
      BitVector* block_doms = dominators[block->id().ToSize()];

      for (BitVector::Iterator it(block_doms); !it.Done(); it.Advance()) {
        BasicBlock* dom =
            schedule->GetBlockById(BasicBlock::Id::FromInt(it.Current()));
        if (dom != idom &&
            !dominators[idom->id().ToSize()]->Contains(dom->id().ToInt())) {
          V8_Fatal(__FILE__, __LINE__,
                   ""Block B%d is not immediately dominated by B%d"",
                   block->rpo_number(), idom->rpo_number());
        }
      }
    }
  }

  // Verify phis are placed in the block of their control input.
  for (BasicBlockVector::iterator b = rpo_order->begin(); b != rpo_order->end();
       ++b) {
    for (BasicBlock::const_iterator i = (*b)->begin(); i != (*b)->end(); ++i) {
      Node* phi = *i;
      if (phi->opcode() != IrOpcode::kPhi) continue;
      // TODO(titzer): Nasty special case. Phis from RawMachineAssembler
      // schedules don't have control inputs.
      if (phi->InputCount() > phi->op()->ValueInputCount()) {
        Node* control = NodeProperties::GetControlInput(phi);
        CHECK(control->opcode() == IrOpcode::kMerge ||
              control->opcode() == IrOpcode::kLoop);
        CHECK_EQ((*b), schedule->block(control));
      }
    }
  }

  // Verify that all uses are dominated by their definitions.
  for (BasicBlockVector::iterator b = rpo_order->begin(); b != rpo_order->end();
       ++b) {
    BasicBlock* block = *b;

    // Check inputs to control for this block.
    Node* control = block->control_input();
    if (control != nullptr) {
      CHECK_EQ(block, schedule->block(control));
      CheckInputsDominate(schedule, block, control,
                          static_cast<int>(block->NodeCount()) - 1);
    }
    // Check inputs for all nodes in the block.
    for (size_t i = 0; i < block->NodeCount(); i++) {
      Node* node = block->NodeAt(i);
      CheckInputsDominate(schedule, block, node, static_cast<int>(i) - 1);
    }
  }
}


#ifdef DEBUG

// static
void Verifier::VerifyNode(Node* node) {
  CHECK_EQ(OperatorProperties::GetTotalInputCount(node->op()),
           node->InputCount());
  // If this node has no effect or no control outputs,
  // we check that no its uses are effect or control inputs.
  bool check_no_control = node->op()->ControlOutputCount() == 0;
  bool check_no_effect = node->op()->EffectOutputCount() == 0;
  bool check_no_frame_state = node->opcode() != IrOpcode::kFrameState;
  if (check_no_effect || check_no_control) {
    for (Edge edge : node->use_edges()) {
      Node* const user = edge.from();
      CHECK(!user->IsDead());
      if (NodeProperties::IsControlEdge(edge)) {
        CHECK(!check_no_control);
      } else if (NodeProperties::IsEffectEdge(edge)) {
        CHECK(!check_no_effect);
      } else if (NodeProperties::IsFrameStateEdge(edge)) {
        CHECK(!check_no_frame_state);
      }
    }
  }
  // Frame state input should be a frame state (or sentinel).
  if (OperatorProperties::GetFrameStateInputCount(node->op()) > 0) {
    Node* input = NodeProperties::GetFrameStateInput(node);
    CHECK(input->opcode() == IrOpcode::kFrameState ||
          input->opcode() == IrOpcode::kStart ||
          input->opcode() == IrOpcode::kDead);
  }
  // Effect inputs should be effect-producing nodes (or sentinels).
  for (int i = 0; i < node->op()->EffectInputCount(); i++) {
    Node* input = NodeProperties::GetEffectInput(node, i);
    CHECK(input->op()->EffectOutputCount() > 0 ||
          input->opcode() == IrOpcode::kDead);
  }
  // Control inputs should be control-producing nodes (or sentinels).
  for (int i = 0; i < node->op()->ControlInputCount(); i++) {
    Node* input = NodeProperties::GetControlInput(node, i);
    CHECK(input->op()->ControlOutputCount() > 0 ||
          input->opcode() == IrOpcode::kDead);
  }
}


void Verifier::VerifyEdgeInputReplacement(const Edge& edge,
                                          const Node* replacement) {
  // Check that the user does not misuse the replacement.
  DCHECK(!NodeProperties::IsControlEdge(edge) ||
         replacement->op()->ControlOutputCount() > 0);
  DCHECK(!NodeProperties::IsEffectEdge(edge) ||
         replacement->op()->EffectOutputCount() > 0);
  DCHECK(!NodeProperties::IsFrameStateEdge(edge) ||
         replacement->opcode() == IrOpcode::kFrameState);
}

#endif  // DEBUG

}  // namespace compiler
}  // namespace internal
}  // namespace v8
",16134,True,3143.690964137281,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
////
= Kubernetes extension

include::./attributes.adoc[]

Quarkus offers the ability to automatically generate Kubernetes resources based on sane defaults and user-supplied configuration using https://github.com/dekorateio/dekorate/[dekorate].
It currently supports generating resources for vanilla <<#kubernetes,Kubernetes>>, <<#openshift,OpenShift>> and <<#knative,Knative>>.
Furthermore, Quarkus can deploy the application to a target Kubernetes cluster by applying the generated manifests to the target cluster's API Server.
Finally, when either one of container image extensions is present (see the xref:container-imag.adoc[container image guide] for more details), Quarkus has the ability to create a container image and push it to a registry *before* deploying the application to the target platform.

== Prerequisites

To complete this guide, you need:

* roughly 10 minutes
* an IDE
* JDK 11+ installed with `JAVA_HOME` configured appropriately
* Apache Maven {maven-version}
* access to a Kubernetes cluster (Minikube is a viable option)

[#kubernetes]
== Kubernetes

Let's create a new project that contains both the Kubernetes and Jib extensions:

[source,bash,subs=attributes+]
----
mvn io.quarkus.platform:quarkus-maven-plugin:{quarkus-version}:create \\
    -DprojectGroupId=org.acme \\
    -DprojectArtifactId=kubernetes-quickstart \\
    -DclassName=""org.acme.rest.GreetingResource"" \\
    -Dpath=""/greeting"" \\
    -Dextensions=""resteasy,kubernetes,jib""
cd kubernetes-quickstart
----

This added the following dependencies to the `pom.xml`

[source,xml]
----
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-kubernetes</artifactId>
    </dependency>
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-container-image-jib</artifactId>
    </dependency>
----

By adding these dependencies, we enable the generation of Kubernetes manifests each time we perform a build while also enabling the build of a container image using Jib.
For example, following the execution of `./mvnw package`, you will notice amongst the other files that are created, two files named
`kubernetes.json` and `kubernetes.yml` in the `target/kubernetes/` directory.

If you look at either file you will see that it contains both a Kubernetes `Deployment` and a `Service`.

The full source of the `kubernetes.json` file looks something like this:

[source,json]
----
{
  {
    ""apiVersion"" : ""apps/v1"",
    ""kind"" : ""Deployment"",
    ""metadata"" : {
      ""annotations"": {
       ""app.quarkus.io/vcs-url"" : ""<some url>"",
       ""app.quarkus.io/commit-id"" : ""<some git SHA>"",
      },
      ""labels"" : {
        ""app.kubernetes.io/name"" : ""test-quarkus-app"",
        ""app.kubernetes.io/version"" : ""1.0.0-SNAPSHOT"",
      },
      ""name"" : ""test-quarkus-app""
    },
    ""spec"" : {
      ""replicas"" : 1,
      ""selector"" : {
        ""matchLabels"" : {
          ""app.kubernetes.io/name"" : ""test-quarkus-app"",
          ""app.kubernetes.io/version"" : ""1.0.0-SNAPSHOT"",
        }
      },
      ""template"" : {
        ""metadata"" : {
          ""labels"" : {
            ""app.kubernetes.io/name"" : ""test-quarkus-app"",
            ""app.kubernetes.io/version"" : ""1.0.0-SNAPSHOT""
          }
        },
        ""spec"" : {
          ""containers"" : [ {
            ""env"" : [ {
              ""name"" : ""KUBERNETES_NAMESPACE"",
              ""valueFrom"" : {
                ""fieldRef"" : {
                  ""fieldPath"" : ""metadata.namespace""
                }
              }
            } ],
            ""image"" : ""yourDockerUsername/test-quarkus-app:1.0.0-SNAPSHOT"",
            ""imagePullPolicy"" : ""Always"",
            ""name"" : ""test-quarkus-app""
          } ]
        }
      }
    }
  },
  {
  ""apiVersion"" : ""v1"",
  ""kind"" : ""Service"",
    ""metadata"" : {
      ""annotations"": {
       ""app.quarkus.io/vcs-url"" : ""<some url>"",
       ""app.quarkus.io/commit-id"" : ""<some git SHA>"",
      },
      ""labels"" : {
        ""app.kubernetes.io/name"" : ""test-quarkus-app"",
        ""app.kubernetes.io/version"" : ""1.0.0-SNAPSHOT"",
      },
      ""name"" : ""test-quarkus-app""
    },
  ""spec"" : {
    ""ports"" : [ {
      ""name"" : ""http"",
      ""port"" : 8080,
      ""targetPort"" : 8080
    } ],
    ""selector"" : {
      ""app.kubernetes.io/name"" : ""test-quarkus-app"",
      ""app.kubernetes.io/version"" : ""1.0.0-SNAPSHOT""
    },
    ""type"" : ""ClusterIP""
  }
 }
}
----

Beside generating a `Deployment` resource, you can also choose to get a `StatefulSet` instead via `application.properties`:

[source,properties]
----
quarkus.kubernetes.deployment-kind=StatefulSet
----

The generated manifest can be applied to the cluster from the project root using `kubectl`:

[source,bash]
----
kubectl apply -f target/kubernetes/kubernetes.json
----

An important thing to note about the `Deployment` (or `StatefulSet`) is that is uses `yourDockerUsername/test-quarkus-app:1.0.0-SNAPSHOT` as the container image of the `Pod`.
The name of the image is controlled by the Jib extension and can be customized using the usual `application.properties`.

For example with a configuration like:

[source,properties]
----
quarkus.container-image.group=quarkus #optional, default to the system user name
quarkus.container-image.name=demo-app #optional, defaults to the application name
quarkus.container-image.tag=1.0       #optional, defaults to the application version
----

The image that will be used in the generated manifests will be `quarkus/demo-app:1.0`

=== Namespace

By default Quarkus omits the namespace in the generated manifests, rather than enforce the `default` namespace. That means that you can apply the manifest to your chosen namespace when using `kubctl`, which in the example below is `test`:

[source,bash]
----
kubectl apply -f target/kubernetes/kubernetes.json -n=test
----

To specify the namespace in your manifest customize with the following property in your `application.properties`:

[source,properties]
----
quarkus.kubernetes.namespace=mynamespace 
----

=== Defining a Docker registry

The Docker registry can be specified with the following property:

[source,properties]
----
quarkus.container-image.registry=my.docker-registry.net
----

By adding this property along with the rest of the container image properties of the previous section, the generated manifests will use the image `my.docker-registry.net/quarkus/demo-app:1.0`.
The image is not the only thing that can be customized in the generated manifests, as will become evident in the following sections.

=== Labels and Annotations

==== Labels

The generated manifests use the Kubernetes link:https://kubernetes.io/docs/concepts/overview/working-with-objects/common-labels[recommended labels].
These labels can be customized using `quarkus.kubernetes.name`, `quarkus.kubernetes.version` and `quarkus.kubernetes.part-of`.
For example by adding the following configuration to your `application.properties`:

[source,properties]
----
quarkus.kubernetes.part-of=todo-app
quarkus.kubernetes.name=todo-rest
quarkus.kubernetes.version=1.0-rc.1
----

[NOTE]
====
As is described in detail in the <<#openshift, OpenShift>> section, customizing OpenShift (or Knative) properties is done in the same way, but replacing
`kubernetes` with `openshift` (or `knative`). The previous example for OpenShift would look like this:

[source,properties]
----
quarkus.openshift.part-of=todo-app
quarkus.openshift.name=todo-rest
quarkus.openshift.version=1.0-rc.1
----
====

The labels in generated resources will look like:

[source, json]
----
  ""labels"" : {
    ""app.kubernetes.io/part-of"" : ""todo-app"",
    ""app.kubernetes.io/name"" : ""todo-rest"",
    ""app.kubernetes.io/version"" : ""1.0-rc.1""
  }
----

==== Custom Labels

To add additional custom labels, for example `foo=bar` just apply the following configuration:

[source,properties]
----
quarkus.kubernetes.labels.foo=bar
----

NOTE: When using the `quarkus-container-image-jib` extension to build a container image, then any label added via the aforementioned property will also be added to the generated container image.

==== Annotations

Out of the box, the generated resources will be annotated with version control related information that can be used either by tooling, or by the user for troubleshooting purposes.

[source,json]
----
  ""annotations"": {
    ""app.quarkus.io/vcs-url"" : ""<some url>"",
    ""app.quarkus.io/commit-id"" : ""<some git SHA>"",
   }
----

==== Custom Annotations

Custom annotations can be added in a way similar to labels.For example to add the annotation `foo=bar` and `app.quarkus/id=42` just apply the following configuration:

[source,properties]
----
quarkus.kubernetes.annotations.foo=bar
quarkus.kubernetes.annotations.""app.quarkus/id""=42
----

[#env-vars]
==== Environment variables

Kubernetes provides multiple ways of defining environment variables:

- key/value pairs
- import all values from a Secret or ConfigMap
- interpolate a single value identified by a given field in a Secret or ConfigMap
- interpolate a value from a field within the same resource

===== Environment variables from key/value pairs

To add a key/value pair as an environment variable in the generated resources:

[source,properties]
----
quarkus.kubernetes.env.vars.my-env-var=foobar
----

The command above will add `MY_ENV_VAR=foobar` as an environment variable.
Please note that the key `my-env-var` will be converted to uppercase and dashes will be replaced by underscores resulting in `MY_ENV_VAR`.

[[secret-mapping]]
===== Environment variables from Secret

To add all key/value pairs of `Secret` as environment variables just apply the following configuration, separating each `Secret`
to be used as source by a comma (`,`):

[source,properties]
----
quarkus.kubernetes.env.secrets=my-secret,my-other-secret
----

which would generate the following in the container definition:

[source,yaml]
----
envFrom:
  - secretRef:
      name: my-secret
      optional: false
  - secretRef:
      name: my-other-secret
      optional: false
----

The following extracts a value identified by the `keyName` field from the `my-secret` Secret into a `foo` environment variable:

[source,properties]
----
quarkus.kubernetes.env.mapping.foo.from-secret=my-secret
quarkus.kubernetes.env.mapping.foo.with-key=keyName
----

This would generate the following in the `env` section of your container:

[source,yaml]
----
- env:
  - name: FOO
    valueFrom:
      secretKeyRef:
        key: keyName
        name: my-secret
        optional: false
----

===== Environment variables from ConfigMap

To add all key/value pairs from `ConfigMap` as environment variables just apply the following configuration, separating each
`ConfigMap` to be used as source by a comma (`,`):

[source,properties]
----
quarkus.kubernetes.env.configmaps=my-config-map,another-config-map
----

which would generate the following in the container definition:

[source,yaml]
----
envFrom:
  - configMapRef:
      name: my-config-map
      optional: false
  - configMapRef:
      name: another-config-map
      optional: false
----

The following extracts a value identified by the `keyName` field from the `my-config-map` ConfigMap into a `foo`
environment variable:

[source,properties]
----
quarkus.kubernetes.env.mapping.foo.from-configmap=my-configmap
quarkus.kubernetes.env.mapping.foo.with-key=keyName
----

This would generate the following in the `env` section of your container:

[source,yaml]
----
- env:
  - name: FOO
    valueFrom:
      configMapRefKey:
        key: keyName
        name: my-configmap
        optional: false
----

===== Environment variables from fields

It's also possible to use the value from another field to add a new environment variable by specifying the path of the field to be used as a source, as follows:

[source,properties]
----
quarkus.kubernetes.env.fields.foo=metadata.name
----

[NOTE]
====
As is described in detail in the <<#openshift, OpenShift>> section, customizing OpenShift properties is done in the same way, but replacing
`kubernetes` with `openshift`. The previous example for OpenShift would look like this:

[source,properties]
----
quarkus.openshift.env.fields.foo=metadata.name
----
====

===== Validation

A conflict between two definitions, e.g. mistakenly assigning both a value and specifying that a variable is derived from a field, will result in an error being thrown at build time so that you get the opportunity to fix the issue before you deploy your application to your cluster where it might be more difficult to diagnose the source of the issue.

Similarly, two redundant definitions, e.g. defining an injection from the same secret twice, will not cause an issue but will indeed report a warning to let you know that you might not have intended to duplicate that definition.

[#env-vars-backwards]
===== Backwards compatibility

Previous versions of the Kubernetes extension supported a different syntax to add environment variables.The older syntax is still supported but is deprecated and it's advised that you migrate to the new syntax.

.Old vs. new syntax
|====
|                               |Old                                                    | New                                                 |
| Plain variable                |`quarkus.kubernetes.env-vars.my-env-var.value=foobar`  | `quarkus.kubernetes.env.vars.my-env-var=foobar`     |
| From field                    |`quarkus.kubernetes.env-vars.my-env-var.field=foobar`  | `quarkus.kubernetes.env.fields.my-env-var=foobar`   |
| All from `ConfigMap`          |`quarkus.kubernetes.env-vars.xxx.configmap=foobar`     | `quarkus.kubernetes.env.configmaps=foobar`          |
| All from `Secret`             |`quarkus.kubernetes.env-vars.xxx.secret=foobar`        | `quarkus.kubernetes.env.secrets=foobar`             |
| From one `Secret` field       |`quarkus.kubernetes.env-vars.foo.secret=foobar`        | `quarkus.kubernetes.env.mapping.foo.from-secret=foobar` |
|                               |`quarkus.kubernetes.env-vars.foo.value=field`          | `quarkus.kubernetes.env.mapping.foo.with-key=field` |
| From one `ConfigMap` field    |`quarkus.kubernetes.env-vars.foo.configmap=foobar`     | `quarkus.kubernetes.env.mapping.foo.from-configmap=foobar` |
|                               |`quarkus.kubernetes.env-vars.foo.value=field`          | `quarkus.kubernetes.env.mapping.foo.with-key=field` |
|====

NOTE: If you redefine the same variable using the new syntax while keeping the old syntax, **ONLY** the new version will be kept
and a warning will be issued to alert you of the problem.For example, if you define both
`quarkus.kubernetes.env-vars.my-env-var.value=foobar` and `quarkus.kubernetes.env.vars.my-env-var=newValue`, the extension will
only generate an environment variable `MY_ENV_VAR=newValue` and issue a warning.

==== Mounting volumes

The Kubernetes extension allows the user to configure both volumes and mounts for the application.
Any volume can be mounted with a simple configuration:

[source,properties]
----
quarkus.kubernetes.mounts.my-volume.path=/where/to/mount
----

This will add a mount to the pod for volume `my-volume` to path `/where/to/mount`.
The volumes themselves can be configured as shown in the sections below.

===== Secret volumes

[source,properties]
----
quarkus.kubernetes.secret-volumes.my-volume.secret-name=my-secret
----

===== ConfigMap volumes

[source,properties]
----
quarkus.kubernetes.config-map-volumes.my-volume.config-map-name=my-secret
----

==== Passing application configuration

Quarkus supports passing configuration from external locations (via Smallrye Config). This usually requires setting an additional environment variable or system propertiy.
When you need to use a secret or a config map for the purpose of application configuration, you need to:

- define a volume
- mount the volume
- create an environment variable for `SMALLRYE_CONFIG_LOCATIONS`

To simplify things, quarkus provides single step alternative:

[source,properties]
----
quarkus.kubernetes.app-secret=<name of the secret containing the configuration>
----

or

[source,properties]
----
quarkus.kubernetes.app-config-map=<name of the config map containing the configuration>
----

When these properties are used, the generated manifests will contain everything required.
The application config volumes will be created using path: `/mnt/app-secret` and `/mnt/app-config-map` for secrets and configmaps respectively.

Note: Users may use both properties at the same time.

=== Changing the number of replicas:

To change the number of replicas from 1 to 3:

[source,properties]
----
quarkus.kubernetes.replicas=3
----

=== Add readiness and liveness probes

By default, the Kubernetes resources do not contain readiness and liveness probes in the generated `Deployment`. Adding them however is just a matter of adding the SmallRye Health extension like so:

[source,xml]
----
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-smallrye-health</artifactId>
    </dependency>
----

The values of the generated probes will be determined by the configured health properties: `quarkus.smallrye-health.root-path`, `quarkus.smallrye-health.liveness-path` and `quarkus.smallrye-health.readiness-path`.
More information about the health extension can be found in the relevant xref:microprofile-health.adoc[guide].

=== Customizing the readiness probe:
To set the initial delay of the probe to 20 seconds and the period to 45:

[source,properties]
----
quarkus.kubernetes.readiness-probe.initial-delay=20s
quarkus.kubernetes.readiness-probe.period=45s
----

=== Add hostAliases
To add entries to a Pod's `/etc/hosts` file (more information can be found in https://kubernetes.io/docs/concepts/services-networking/add-entries-to-pod-etc-hosts-with-host-aliases/[Kubernetes documentation]), just apply the following configuration:

[source,properties]
----
quarkus.kubernetes.hostaliases.""10.0.0.0"".hostnames=foo.com,bar.org
----

This would generate the following `hostAliases` section in the `deployment` definition:

[source,yaml]
----
kind: Deployment
spec:
  template:
    spec:
      hostAliases:
      - hostnames:
        - foo.com
        - bar.org
        ip: 10.0.0.0
----

=== Container Resources Management

CPU & Memory limits and requests can be applied to a `Container` (more info in https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/[Kubernetes documentation]) using the following configuration:

[source]
----
quarkus.kubernetes.resources.requests.memory=64Mi
quarkus.kubernetes.resources.requests.cpu=250m
quarkus.kubernetes.resources.limits.memory=512Mi
quarkus.kubernetes.resources.limits.cpu=1000m
----

This would generate the following entry in the `container` section:

[source, yaml]
----
containers:
  resources:
    limits:
      cpu: 1000m
      memory: 512Mi
    requests:
      cpu: 250m
      memory: 64Mi
----

=== Using the Kubernetes client

Applications that are deployed to Kubernetes and need to access the API server will usually make use of the `kubernetes-client` extension:

[source,xml]
----
    <dependency>
      <groupId>io.quarkus</groupId>
      <artifactId>quarkus-kubernetes-client</artifactId>
    </dependency>
----

To access the API server from within a Kubernetes cluster, some RBAC related resources are required (e.g. a ServiceAccount, a RoleBinding etc.).
So, when the `kubernetes-client` extension is present, the `kubernetes` extension is going to create those resources automatically, so that application will be granted the `view` role.
If more roles are required, they will have to be added manually.

=== Deploying to Minikube

https://github.com/kubernetes/minikube[Minikube] is quite popular when a Kubernetes cluster is needed for development purposes. To make the deployment to Minikube
experience as frictionless as possible, Quarkus provides the `quarkus-minikube` extension. This extension can be added to a project like so:

[source,xml]
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-minikube</artifactId>
</dependency>
----

The purpose of this extension is to generate Kubernetes manifests (`minikube.yaml` and `minikube.json`) that are tailored to Minikube.
This extension assumes a couple things:

* Users won't be using an image registry and will instead make their container image accessible to the Kubernetes cluster by building it directly
into Minikube's Docker daemon. To use Minikube's Docker daemon you must first execute:
+
[source,bash]
----
eval $(minikube -p minikube docker-env)
----

* Applications deployed to Kubernetes won't be accessed via a Kubernetes `Ingress`, but rather as a `NodePort` `Service`.
The advantage of doing this is that the URL of an application can be retrieved trivially by executing:
+
[source,bash]
----
minikube service list
----

To control the https://kubernetes.io/docs/concepts/services-networking/service/#nodeport[nodePort] that is used in this case, users can set `quarkus.kubernetes.node-port`.
Note however that this configuration is entirely optional because Quarkus will automatically use a proper (and non-changing) value if none is set.

WARNING: It is highly discouraged to use the manifests generated by the Minikube extension when deploying to production as these manifests are intended for development purposes
only. When deploying to production, consider using the vanilla Kubernetes manifests (or the OpenShift ones when targeting OpenShift).

NOTE: If the assumptions the Minikube extension makes don't fit your workflow, nothing prevents you from using the regular Kubernetes extension to generate Kubernetes manifests
and apply those to your Minikube cluster.

== Tuning the generated resources using application.properties

The Kubernetes extension allows tuning the generated manifest, using the `application.properties` file.
Here are some examples:

=== Configuration options

The table below describe all the available configuration options.

.Kubernetes
|====
| Property                                           | Type                                      | Description | Default Value
| quarkus.kubernetes.name                            | String                                    |             | ${quarkus.container-image.name}
| quarkus.kubernetes.version                         | String                                    |             | ${quarkus.container-image.tag}
| quarkus.kubernetes.deployment-kind                 | String                                    |             | Deployment
| quarkus.kubernetes.part-of                         | String                                    |             |
| quarkus.kubernetes.init-containers                 | Map<String, Container>                    |             |
| quarkus.kubernetes.namespace                       | String                                    |             |
| quarkus.kubernetes.labels                          | Map                                       |             |
| quarkus.kubernetes.annotations                     | Map                                       |             |
| quarkus.kubernetes.app-secret                      | String                                    |             |
| quarkus.kubernetes.app-config-map                  | String                                    |             |
| quarkus.kubernetes.env-vars                        | Map<String, Env>                          |             |
| quarkus.kubernetes.working-dir                     | String                                    |             |
| quarkus.kubernetes.command                         | String[]                                  |             |
| quarkus.kubernetes.arguments                       | String[]                                  |             |
| quarkus.kubernetes.replicas                        | int                                       |             | 1
| quarkus.kubernetes.service-account                 | String                                    |             |
| quarkus.kubernetes.ports                           | Map<String, Port>                         |             |
| quarkus.kubernetes.service-type                    | ServiceType                               |             | ClusterIP
| quarkus.kubernetes.pvc-volumes                     | Map<String, PersistentVolumeClaimVolume>  |             |
| quarkus.kubernetes.secret-volumes                  | Map<String, SecretVolume>                 |             |
| quarkus.kubernetes.config-map-volumes              | Map<String, ConfigMapVolume>              |             |
| quarkus.kubernetes.git-repo-volumes                | Map<String, GitRepoVolume>                |             |
| quarkus.kubernetes.aws-elastic-block-store-volumes | Map<String, AwsElasticBlockStoreVolume>   |             |
| quarkus.kubernetes.azure-disk-volumes              | Map<String, AzureDiskVolume>              |             |
| quarkus.kubernetes.azure-file-volumes              | Map<String, AzureFileVolume>              |             |
| quarkus.kubernetes.mounts                          | Map<String, Mount>                        |             |
| quarkus.kubernetes.image-pull-policy               | ImagePullPolicy                           |             | Always
| quarkus.kubernetes.image-pull-secrets              | String[]                                  |             |
| quarkus.kubernetes.liveness-probe                  | Probe                                     |             | ( see Probe )
| quarkus.kubernetes.readiness-probe                 | Probe                                     |             | ( see Probe )
| quarkus.kubernetes.sidecars                        | Map<String, Container>                    |             |
| quarkus.kubernetes.ingress.expose                  | boolean                                   |             | false
| quarkus.kubernetes.ingress.host                    | String                                    |             |
| quarkus.kubernetes.ingress.annotations             | Map<String, String>                       |             |
| quarkus.kubernetes.headless                        | boolean                                   |             | false
| quarkus.kubernetes.hostaliases                     | Map<String, HostAlias>                    |             |
| quarkus.kubernetes.resources.requests.cpu          | String                                    |             |
| quarkus.kubernetes.resources.requests.memory       | String                                    |             |
| quarkus.kubernetes.resources.limits.cpu            | String                                    |             |
| quarkus.kubernetes.resources.limits.memory         | String                                    |             |
|====

Properties that use non-standard types, can be referenced by expanding the property.
For example to define a `kubernetes-readiness-probe` which is of type `Probe`:

[source,properties]
----
quarkus.kubernetes.readiness-probe.initial-delay=20s
quarkus.kubernetes.readiness-probe.period=45s
----

In this example `initial-delay` and `period` are fields of the type `Probe`.
Below you will find tables describing all available types.

==== Client Connection Configuration
You may need to configure the connection to your Kubernetes cluster.
By default, it automatically uses the active _context_ used by `kubectl`.

For instance, if your cluster API endpoint uses a self-signed SSL Certificate you need to explicitly configure the client to trust it. You can achieve this by defining the following property:

[source,properties]
----
quarkus.kubernetes-client.trust-certs=true
----

The full list of the Kuberneters client configuration properties is provided below.

include::{generated-dir}/config/quarkus-kubernetes-client.adoc[opts=optional, leveloffset=+1]

==== Basic Types

.ServiceType
Allowed values: `cluster-ip`, `node-port`, `load-balancer`, `external-name`

.Env
|====
| Property  | Type   | Description | Default Value
| value     | String |             |
| secret    | String |             |
| configmap | String |             |
| field     | String |             |
|====

.Probe
|====
| Property              | Type     | Description | Default Value
| http-action-path      | String   |             |
| exec-action           | String   |             |
| tcp-socket-action     | String   |             |
| initial-delay         | Duration |             |             0
| period                | Duration |             |           30s
| timeout               | Duration |             |           10s
|====

.Port
|====
| Property        | Type     | Description | Default Value
| container-port  | int      |             |
| host-port       | int      |             | 0
| path            | String   |             | /
| protocol        | Protocol |             | TCP
|====

.Container
|====
| Property          | Type                                    | Description | Default Value
| image             | String                                  |             |
| env-vars          | Env[]                                   |             |
| working-dir       | String                                  |             |
| command           | String[]                                |             |
| arguments         | String[]                                |             |
| ports             | Port[]                                  |             |
| mounts            | Mount[]                                 |             |
| image-pull-policy | ImagePullPolicy                         |             | Always
| liveness-probe    | Probe                                   |             |
| readiness-probe   | Probe                                   |             |
|====

.HostAlias
|====
| Property    | Type     | Description       | Default Value
| hostnames   | String[] | list of hostnames |
|====

==== Mounts and Volumes

.Mount
|====
| Property  | Type    | Description | Default Value
| path      | String  |             |
| sub-path  | String  |             |
| read-only | boolean |             | false
|====

.ConfigMapVolume
|====
| Property        | Type    | Description | Default Value
| config-map-name | String  |             |
| default-mode    | int     |             | 0600
| optional        | boolean |             | false
|====

.SecretVolume
|====
| Property     | Type    | Description | Default Value
| secret-name  | String  |             |
| default-mode | int     |             | 0600
| optional     | boolean |             | false
|====


.AzureDiskVolume
|====
| Property     | Type    | Description | Default Value
| disk-name    | String  |             |
| disk-uri     | String  |             |
| kind         | String  |             | Managed
| caching-mode | String  |             | ReadWrite
| fs-type      | String  |             | ext4
| read-only    | boolean |             | false
|====

.AwsElasticBlockStoreVolume
|====
| Property    | Type    | Description | Default Value
| volume-id   | String  |             |
| partition   | int     |             |
| fs-type     | String  |             | ext4
| read-only   | boolean |             | false
|====

.GitRepoVolume
|====
| Property    | Type   | Description | Default Value
| repository  | String |             |
| directory   | String |             |
| revision    | String |             |
|====

.PersistentVolumeClaimVolume
|====
| Property    | Type    | Description | Default Value
| claim-name  | String  |             |
| read-only   | boolean |             | false
|====

.AzureFileVolume
|====
| Property    | Type    | Description | Default Value
| share-name  | String  |             |
| secret-name | String  |             |
| read-only   | boolean |             | false
|====

[#openshift]
=== OpenShift

One way to deploy an application to OpenShift is to use s2i (source to image) to create an image stream from the source and then deploy the image stream:

[source,bash]
----
./mvnw quarkus:remove-extension -Dextensions=""kubernetes, jib""
./mvnw quarkus:add-extension -Dextensions=""openshift""

oc new-project quarkus-project
./mvnw clean package -Dquarkus.container-image.build=true 

oc new-app --name=greeting  quarkus-project/kubernetes-quickstart:1.0.0-SNAPSHOT
oc expose svc/greeting
oc get route
curl <route>/greeting
----

See further information in xref:deploying-to-openshift.adoc[Deploying to OpenShift].

A description of OpenShift resources and customisable properties is given below alongside Kubernetes resources to show similarities where applicable.   This includes an alternative to  `oc new-app ...` above, i.e. `oc apply -f target/kubernetes/openshift.json` .

To enable the generation of OpenShift resources, you need to include OpenShift in the target platforms:

[source,properties]
----
quarkus.kubernetes.deployment-target=openshift
----

If you need to generate resources for both platforms (vanilla Kubernetes and OpenShift), then you need to include both (comma separated).

[source,properties]
----
quarkus.kubernetes.deployment-target=kubernetes,openshift
----

Following the execution of `./mvnw package -Dquarkus.container-image.build=true ` you will notice amongst the other files that are created, two files named
`openshift.json` and `openshift.yml` in the `target/kubernetes/` directory.

These manifests can be deployed as is to a running cluster, using `kubectl`:

[source,bash]
----
kubectl apply -f target/kubernetes/openshift.json
----

OpenShift users might want to use `oc` instead of `kubectl`:

[source,bash]
----
oc apply -f target/kubernetes/openshift.json
----


NOTE: Quarkus also provides the xref:deploying-to-openshift.adoc[OpenShift] extension. This extension is basically a wrapper around the Kubernetes extension and
relieves OpenShift users of the necessity of setting the `deployment-target` property to `openshift`

The OpenShift resources can be customized in a similar approach with Kubernetes.

.OpenShift
|====
| Property                                          | Type                                      | Description | Default Value
| quarkus.openshift.name                            | String                                    |             | ${quarkus.container-image.name}
| quarkus.openshift.version                         | String                                    |             | ${quarkus.container-image.tag}
| quarkus.openshift.deployment-kind                 | String                                    |             | DeploymentConfig
| quarkus.openshift.part-of                         | String                                    |             |
| quarkus.openshift.init-containers                 | Map<String, Container>                    |             |
| quarkus.openshift.labels                          | Map                                       |             |
| quarkus.openshift.annotations                     | Map                                       |             |
| quarkus.openshift.app-secret                      | String                                    |             |
| quarkus.openshift.app-config-map                  | String                                    |             |
| quarkus.openshift.env-vars                        | Map<String, Env>                          |             |
| quarkus.openshift.working-dir                     | String                                    |             |
| quarkus.openshift.command                         | String[]                                  |             |
| quarkus.openshift.arguments                       | String[]                                  |             |
| quarkus.openshift.replicas                        | int                                       |             | 1
| quarkus.openshift.service-account                 | String                                    |             |
| quarkus.openshift.ports                           | Map<String, Port>                         |             |
| quarkus.openshift.service-type                    | ServiceType                               |             | ClusterIP
| quarkus.openshift.pvc-volumes                     | Map<String, PersistentVolumeClaimVolume>  |             |
| quarkus.openshift.secret-volumes                  | Map<String, SecretVolume>                 |             |
| quarkus.openshift.config-map-volumes              | Map<String, ConfigMapVolume>              |             |
| quarkus.openshift.git-repo-volumes                | Map<String, GitRepoVolume>                |             |
| quarkus.openshift.aws-elastic-block-store-volumes | Map<String, AwsElasticBlockStoreVolume>   |             |
| quarkus.openshift.azure-disk-volumes              | Map<String, AzureDiskVolume>              |             |
| quarkus.openshift.azure-file-volumes              | Map<String, AzureFileVolume>              |             |
| quarkus.openshift.mounts                          | Map<String, Mount>                        |             |
| quarkus.openshift.image-pull-policy               | ImagePullPolicy                           |             | Always
| quarkus.openshift.image-pull-secrets              | String[]                                  |             |
| quarkus.openshift.liveness-probe                  | Probe                                     |             | ( see Probe )
| quarkus.openshift.readiness-probe                 | Probe                                     |             | ( see Probe )
| quarkus.openshift.sidecars                        | Map<String, Container>                    |             |
| quarkus.openshift.route.expose                    | boolean                                   |             | false
| quarkus.openshift.route.host                      | String                                    |             |
| quarkus.openshift.route.annotations               | Map<String, String>                       |             |
| quarkus.openshift.headless                        | boolean                                   |             | false
|====

[#knative]
=== Knative

To enable the generation of Knative resources, you need to include Knative in the target platforms:

[source,properties]
----
quarkus.kubernetes.deployment-target=knative
----

Following the execution of `./mvnw package` you will notice amongst the other files that are created, two files named
`knative.json` and `knative.yml` in the `target/kubernetes/` directory.

If you look at either file you will see that it contains a Knative `Service`.

The full source of the `knative.json` file looks something like this:

[source,json]
----
{
  {
    ""apiVersion"" : ""serving.quarkus.knative.dev/v1alpha1"",
    ""kind"" : ""Service"",
    ""metadata"" : {
      ""annotations"": {
       ""app.quarkus.io/vcs-url"" : ""<some url>"",
       ""app.quarkus.io/commit-id"" : ""<some git SHA>""
      },
      ""labels"" : {
        ""app.kubernetes.io/name"" : ""test-quarkus-app"",
        ""app.kubernetes.io/version"" : ""1.0.0-SNAPSHOT""
      },
      ""name"" : ""knative.
    },
    ""spec"" : {
      ""runLatest"" : {
        ""configuration"" : {
          ""revisionTemplate"" : {
            ""spec"" : {
              ""container"" : {
                ""image"" : ""dev.local/yourDockerUsername/test-quarkus-app:1.0.0-SNAPSHOT"",
                ""imagePullPolicy"" : ""Always""
              }
            }
          }
        }
      }
    }
  }
}
----

The generated manifest can be deployed as is to a running cluster, using `kubectl`:

[source,bash]
----
kubectl apply -f target/kubernetes/knative.json
----

The generated service can be customized using the following properties:

.Knative
|====
| Property                                        | Type                                      | Description | Default Value
| quarkus.knative.name                            | String                                    |             | ${quarkus.container-image.name}
| quarkus.knative.version                         | String                                    |             | ${quarkus.container-image.tag}
| quarkus.knative.part-of                         | String                                    |             |
| quarkus.knative.init-containers                 | Map<String, Container>                    |             |
| quarkus.knative.labels                          | Map                                       |             |
| quarkus.knative.annotations                     | Map                                       |             |
| quarkus.knative.app-secret                      | String                                    |             |
| quarkus.knative.app-config-map                  | String                                    |             |
| quarkus.knative.env-vars                        | Map<String, Env>                          |             |
| quarkus.knative.working-dir                     | String                                    |             |
| quarkus.knative.command                         | String[]                                  |             |
| quarkus.knative.arguments                       | String[]                                  |             |
| quarkus.knative.replicas                        | int                                       |             | 1
| quarkus.knative.service-account                 | String                                    |             |
| quarkus.knative.host                            | String                                    |             |
| quarkus.knative.ports                           | Map<String, Port>                         |             |
| quarkus.knative.service-type                    | ServiceType                               |             | ClusterIP
| quarkus.knative.pvc-volumes                     | Map<String, PersistentVolumeClaimVolume>  |             |
| quarkus.knative.secret-volumes                  | Map<String, SecretVolume>                 |             |
| quarkus.knative.config-map-volumes              | Map<String, ConfigMapVolume>              |             |
| quarkus.knative.git-repo-volumes                | Map<String, GitRepoVolume>                |             |
| quarkus.knative.aws-elastic-block-store-volumes | Map<String, AwsElasticBlockStoreVolume>   |             |
| quarkus.knative.azure-disk-volumes              | Map<String, AzureDiskVolume>              |             |
| quarkus.knative.azure-file-volumes              | Map<String, AzureFileVolume>              |             |
| quarkus.knative.mounts                          | Map<String, Mount>                        |             |
| quarkus.knative.image-pull-policy               | ImagePullPolicy                           |             | Always
| quarkus.knative.image-pull-secrets              | String[]                                  |             |
| quarkus.knative.liveness-probe                  | Probe                                     |             | ( see Probe )
| quarkus.knative.readiness-probe                 | Probe                                     |             | ( see Probe )
| quarkus.knative.sidecars                        | Map<String, Container>                    |             |
| quarkus.knative.revision-name                   | String                                    |             | 
| quarkus.knative.traffic                         | Traffic[]                                 |             | ( see Traffic)
|====

.Traffic
|====
| Property        | Type    | Description | Default Value
| revision-name   | String  | A specific revision to which to send this portion of traffic                                    |
| tag             | String  | Expose a dedicated url for referncing this target                                               |
| latest-revision | Boolean | Optionally provided to indicate that the latest revision should be used for this traffic target | false 
| percent         | Logn    | Indicates the percent of traffic that is be routed to this revision                             | 100
|====


=== Deployment targets

Mentioned in the previous sections was the concept of `deployment-target`. This concept allows users to control which Kubernetes manifests will be generated
and deployed to a cluster (if `quarkus.kubernetes.deploy` has been set to `true`).

By default, when no `deployment-target` is set, then only vanilla Kubernetes resources are generated and deployed. When multiple values are set (for example
`quarkus.kubernetes.deployment-target=kubernetes,openshift`) then the resources for all targets are generated, but only the resources
that correspond to the *first* target are applied to the cluster (if deployment is enabled).

In the case of wrapper extensions like OpenShift and Minikube, when these extensions have been explicitly added to the project, the default `deployment-target`
is set by those extensions. For example if `quarkus-minikube` has been added to a project, then `minikube` becomes the default deployment target and its
resources will be applied to the Kubernetes cluster when deployment via `quarkus.kubernetes.deploy` has been set.
Users can still override the deployment-targets manually using `quarkus.kubernetes.deployment-target`.

=== Deprecated configuration

The following categories of configuration properties have been deprecated.

==== Properties without the quarkus prefix

In earlier versions of the extension, the `quarkus.` was missing from those properties. These properties are now deprecated.

==== Docker and S2i properties

The properties for configuring `docker` and `s2i` are also deprecated in favor of the new container-image extensions.

==== Config group arrays

Properties referring to config group arrays (e.g. `kubernetes.labels[0]`, `kubernetes.env-vars[0]` etc) have been converted to maps, to align with the rest of the Quarkus ecosystem.

The code below demonstrates the change in `labels` config:

[source,properties]
----
# Old labels config:
kubernetes.labels[0].name=foo
kubernetes.labels[0].value=bar

# New labels
quarkus.kubernetes.labels.foo=bar
----

The code below demonstrates the change in `env-vars` config:

[source,properties]
----
# Old env-vars config:
kubernetes.env-vars[0].name=foo
kubernetes.env-vars[0].configmap=my-configmap

# New env-vars
quarkus.kubernetes.env-vars.foo.configmap=myconfigmap
----

==== `env-vars` properties

`quarkus.kubernetes.env-vars` are deprecated (though still currently supported as of this writing) and the new declaration style should be used instead.
See <<#env-vars>> and more specifically <<env-vars-backwards>> for more details.

== Deployment

To trigger building and deploying a container image you need to enable the `quarkus.kubernetes.deploy` flag (the flag is disabled by default - furthermore it has no effect during test runs or dev mode).
This can be easily done with the command line:

[source,bash,subs=attributes+]
----
./mvnw clean package -Dquarkus.kubernetes.deploy=true
----

=== Building a container image

Building a container image is possible, using any of the 3 available `container-image` extensions:

- xref:container-image.adoc#docker[Docker]
- xref:container-image.adoc#jib[Jib]
- xref:container-image.adoc#s2i[s2i]

Each time deployment is requested, a container image build will be implicitly triggered (no additional properties are required when the Kubernetes deployment has been enabled).

=== Deploying

When deployment is enabled, the Kubernetes extension will select the resources specified by `quarkus.kubernetes.deployment-target` and deploy them.
This assumes that a `.kube/config` is available in your user directory that points to the target Kubernetes cluster.
In other words the extension will use whatever cluster `kubectl` uses. The same applies to credentials.

At the moment no additional options are provided for further customization.

== Using existing resources

Sometimes it's desirable to either provide additional resources (e.g. a ConfigMap, a Secret, a Deployment for a database etc) or provide custom ones that will be used as a `base` for the generation process.
Those resources can be added under `src/main/kubernetes` directory and can be named after the target environment (e.g. kubernetes.json, openshift.json, knative.json, or the yml equivalents). Each of these files may contain one or more Kubernetes resources.

Any resource found will be added in the generated manifests. Global modifications (e.g. labels, annotations etc) will also be applied to those resources.
If one of the provided resources has the same name as one of the generated ones, then the generated resource will be created on top of the provided resource, respecting existing content when possible (e.g. existing labels, annotations, environment variables, mounts, replicas etc).

The name of the resource is determined by the application name and may be overridden by `quarkus.kubernetes.name`, `quarkus.openshift.name` and `quarkus.knative.name`.

For example, in the `kubernetes-quickstart` application, we can add a `kubernetes.yml` file in the `src/main/kubernetes` that looks like:

[source,yaml]
----
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubernetes-quickstart
  labels:
    app: quickstart
spec:
  replicas: 3
  selector:
    matchLabels:
      app: quickstart
  template:
    metadata:
      labels:
        app: quickstart
    spec:
      containers:
      - name: kubernetes-quickstart
        image: someimage:latest
        ports:
        - containerPort: 80
        env:
        - name: FOO
          value: BAR
----

The generated `kubernetes.yml` will look like:

[source,yaml]
----
apiVersion: ""apps/v1""
kind: ""Deployment""
metadata:
  annotations:
    app.quarkus.io/build-timestamp: ""2020-04-10 - 12:54:37 +0000""
  labels:
    app: ""quickstart""
  name: ""kubernetes-quickstart""
spec:
  replicas: 3 <1>
  selector:
    matchLabels:
      app.kubernetes.io/name: ""kubernetes-quickstart""
      app.kubernetes.io/version: ""1.0.0-SNAPSHOT""
  template:
    metadata:
      annotations:
        app.quarkus.io/build-timestamp: ""2020-04-10 - 12:54:37 +0000""
      labels:
        app: ""quickstart"" <2>
    spec:
      containers:
      - env:
        - name: ""FOO"" <3>
          value: ""BAR""
        image: ""<<yourDockerUsername>>/kubernetes-quickstart:1.0.0-SNAPSHOT"" <4>
        imagePullPolicy: ""Always""
        name: ""kubernetes-quickstart""
        ports:
        - containerPort: 8080 <5>
          name: ""http""
          protocol: ""TCP""
      serviceAccount: ""kubernetes-quickstart""
----

The provided replicas <1>, labels <2> and environment variables <3>  were retained. However, the image <4> and container port <5> were modified. Moreover, the default annotations have been added.

[NOTE]
====
If the resource name does not match the application name (or the overridden name) instead of reusing the resource a new one will be added. Same goes for the container.
If the name of the container does not match the application name (or the overridden name), container specific configuration will be ignored.
====

== Service Binding [[service_binding]]

Quarkus supports binding services to applications via the link:https://github.com/k8s-service-bindings/spec[Service Binding Specification for Kubernetes].
Specifically Quarkus implements the link:https://github.com/k8s-service-bindings/spec#workload-projection[Workload Projection] part of the specification, thus allowing
applications running in appropriately configured Kubernetes clusters to consume services (such as a Database or a Broker) without the need for user configuration.

Currently, the following Quarkus extensions (and extensions that depend on these) support this feature:

* quarkus-jdbc-mariadb
* quarkus-jdbc-mssql
* quarkus-jdbc-mysql
* quarkus-jdbc-postgresql
* quarkus-kafka-client
* quarkus-smallrye-reactive-messaging-kafka
* quarkus-mongo-client

This list of extensions will grow as more services with supported bindings become available on Kubernetes.

To enable Service Binding support, in addition to one of the currently supported extensions, the `quarkus-kubernetes-service-binding` extension needs to be added to the application dependencies.

=== Example using PostgreSQL

If the Kubernetes cluster in which your Quarkus application runs supports provisioning a PostgreSQL database, one could use the following dependencies to take advantage of the Service Binding feature:

[source,xml]
----
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-jdbc-postgresql</artifactId>
        </dependency>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-kubernetes-service-binding</artifactId>
        </dependency>

       <!-- Hibernate isn't necessary for Service Binding, but most relational database access will benefit from using it -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-hibernate-orm</artifactId>
        </dependency>
----

The configuration of the application could be as simple as:

[source,properties]
----
quarkus.hibernate-orm.database.generation=validate
----

You'll notice that all the configuration for the datasource is absent, as it will be auto-discovered by Quarkus when the application is deployed to Kubernetes.

=== How does it work?

When the application is deployed to an appropriately configured Kubernetes cluster, Kubernetes will create on the filesystem a set of files containing the runtime configuration (for example a file containing the URL of the database, another for the username).
Quarkus knows where in the file system to look for these files (as it consults the `SERVICE_BINDING_ROOT` environment variable which is set by Kubernetes) and if they exist, Quarkus knows how to map the values of these files to the appropriate extension configuration properties.

An example of what the file system looks like can be seen link:https://github.com/quarkusio/quarkus/tree/e7efe6b3efba91b9c4ae26f9318f8397e23e7505/integration-tests/kubernetes-service-binding-jdbc/src/test/resources/k8s-sb[here].
In that example, the `k8s-sb` directory is meant to be the root of all service bindings. Only one binding which exists in that case and it is named `fruit-db`. This binding has a `type` file indicating that it is a `postgresql` database
while the other files provide the necessary connection information.

=== Generating ServiceBinding resources
The <<service_binding, Service Binding>> covers, how the application will consume the bound service. 
However, we still haven't touched on how the actual binding happens. The binding is the responsibility of the Service Binding Operator. The user provides a `ServiceBinding` resource which expresses which application will bound to which services and the operator is responsible for mounting the required files to container.

A `ServiceBinding` looks like:

[source,yaml]
----
apiVersion: binding.operators.coreos.com/v1alpha1
kind: ServiceBinding
metadata:
  name: binding-request
  namespace: service-binding-demo
spec:
  application:
    name: java-app
    group: apps
    version: v1
    resource: deployments
  services:
  - group: postgresql.baiju.dev
    version: v1alpha1
    kind: Database
    name: db-demo
    id: postgresDB
----

The `quarkus-kubernetes-service-binding` extension provides a more compact way of expressing this information:

[source,properties]
----
quarkus.kubernetes-service-binding.services.db-demo.api-version=postgresql.baiju.dev/v1alpha1
quarkus.kubernetes-service-binding.services.db-demo.kind=Database
----

By adding the above configuration properties inside your `application.properties` the `quarkus-kubernetes` in cooperation with the `quarkus-kubernetes-service-binding` extension will generate the `ServiceBinding` for you.
And this is something that is meant to work regardles of the kubernets flavour you are using, so it's expected to also work for Openshift and Knative, without any additional action from the user.

In the configuration above `db-demo` has a double role. It is used to correlate / group `api-version` and `kind` together, but it's also used as the `name` of the custom resource. The later can be overriden if needed. For example:

[source,properties]
----
quarkus.kubernetes-service-binding.services.db-demo.api-version=postgresql.baiju.dev/v1alpha1
quarkus.kubernetes-service-binding.services.db-demo.kind=Database
quarkus.kubernetes-service-binding.services.db-demo.name=my-db
----

NOTE: Advanced, features (e.g. `ServiceBiniding` mappings) are not yet supported.

Here is the list of: link:https://github.com/redhat-developer/service-binding-operator#known-bindable-operators[Known bindable Operators].


[TIP]
====
For more details on how the discovery of the available properties works, please read the link:https://github.com/k8s-service-bindings/spec#workload-projection[Workload Projection] part of the Service Binding specification.
====
",12218,False,2234.7101100463346,median
"// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// FLUTTER_NOLINT
// FLUTTER_NOLINT

#define FML_USED_ON_EMBEDDER
#define RAPIDJSON_HAS_STDSTRING 1

#include <cstring>
#include <iostream>
#include <memory>
#include <set>
#include <string>
#include <vector>

#include ""flutter/fml/build_config.h""
#include ""flutter/fml/closure.h""
#include ""flutter/fml/make_copyable.h""
#include ""flutter/fml/native_library.h""
#include ""third_party/dart/runtime/bin/elf_loader.h""
#include ""third_party/dart/runtime/include/dart_native_api.h""

#if !defined(FLUTTER_NO_EXPORT)
#if OS_WIN
#define FLUTTER_EXPORT __declspec(dllexport)
#else  // OS_WIN
#define FLUTTER_EXPORT __attribute__((visibility(""default"")))
#endif  // OS_WIN
#endif  // !FLUTTER_NO_EXPORT

extern ""C"" {
#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
// Used for debugging dart:* sources.
extern const uint8_t kPlatformStrongDill[];
extern const intptr_t kPlatformStrongDillSize;
#endif  // FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
}

#include ""flutter/assets/directory_asset_bundle.h""
#include ""flutter/common/task_runners.h""
#include ""flutter/fml/command_line.h""
#include ""flutter/fml/file.h""
#include ""flutter/fml/make_copyable.h""
#include ""flutter/fml/message_loop.h""
#include ""flutter/fml/paths.h""
#include ""flutter/fml/trace_event.h""
#include ""flutter/shell/common/persistent_cache.h""
#include ""flutter/shell/common/rasterizer.h""
#include ""flutter/shell/common/switches.h""
#include ""flutter/shell/platform/embedder/embedder.h""
#include ""flutter/shell/platform/embedder/embedder_engine.h""
#include ""flutter/shell/platform/embedder/embedder_platform_message_response.h""
#include ""flutter/shell/platform/embedder/embedder_render_target.h""
#include ""flutter/shell/platform/embedder/embedder_safe_access.h""
#include ""flutter/shell/platform/embedder/embedder_task_runner.h""
#include ""flutter/shell/platform/embedder/embedder_thread_host.h""
#include ""flutter/shell/platform/embedder/platform_view_embedder.h""
#include ""rapidjson/rapidjson.h""
#include ""rapidjson/writer.h""

const int32_t kFlutterSemanticsNodeIdBatchEnd = -1;
const int32_t kFlutterSemanticsCustomActionIdBatchEnd = -1;

static FlutterEngineResult LogEmbedderError(FlutterEngineResult code,
                                            const char* reason,
                                            const char* code_name,
                                            const char* function,
                                            const char* file,
                                            int line) {
#if OS_WIN
  constexpr char kSeparator = '\\\\';
#else
  constexpr char kSeparator = '/';
#endif
  const auto file_base =
      (::strrchr(file, kSeparator) ? strrchr(file, kSeparator) + 1 : file);
  char error[256] = {};
  snprintf(error, (sizeof(error) / sizeof(char)),
           ""%s (%d): '%s' returned '%s'. %s"", file_base, line, function,
           code_name, reason);
  std::cerr << error << std::endl;
  return code;
}

#define LOG_EMBEDDER_ERROR(code, reason) \\
  LogEmbedderError(code, reason, #code, __FUNCTION__, __FILE__, __LINE__)

static bool IsOpenGLRendererConfigValid(const FlutterRendererConfig* config) {
  if (config->type != kOpenGL) {
    return false;
  }

  const FlutterOpenGLRendererConfig* open_gl_config = &config->open_gl;

  if (!SAFE_EXISTS(open_gl_config, make_current) ||
      !SAFE_EXISTS(open_gl_config, clear_current) ||
      !SAFE_EXISTS_ONE_OF(open_gl_config, fbo_callback,
                          fbo_with_frame_info_callback) ||
      !SAFE_EXISTS_ONE_OF(open_gl_config, present, present_with_info)) {
    return false;
  }

  return true;
}

static bool IsSoftwareRendererConfigValid(const FlutterRendererConfig* config) {
  if (config->type != kSoftware) {
    return false;
  }

  const FlutterSoftwareRendererConfig* software_config = &config->software;

  if (SAFE_ACCESS(software_config, surface_present_callback, nullptr) ==
      nullptr) {
    return false;
  }

  return true;
}

static bool IsRendererValid(const FlutterRendererConfig* config) {
  if (config == nullptr) {
    return false;
  }

  switch (config->type) {
    case kOpenGL:
      return IsOpenGLRendererConfigValid(config);
    case kSoftware:
      return IsSoftwareRendererConfigValid(config);
    default:
      return false;
  }

  return false;
}

#if OS_LINUX || OS_WIN
static void* DefaultGLProcResolver(const char* name) {
  static fml::RefPtr<fml::NativeLibrary> proc_library =
#if OS_LINUX
      fml::NativeLibrary::CreateForCurrentProcess();
#elif OS_WIN  // OS_LINUX
      fml::NativeLibrary::Create(""opengl32.dll"");
#endif        // OS_WIN
  return static_cast<void*>(
      const_cast<uint8_t*>(proc_library->ResolveSymbol(name)));
}
#endif  // OS_LINUX || OS_WIN

static flutter::Shell::CreateCallback<flutter::PlatformView>
InferOpenGLPlatformViewCreationCallback(
    const FlutterRendererConfig* config,
    void* user_data,
    flutter::PlatformViewEmbedder::PlatformDispatchTable
        platform_dispatch_table,
    std::unique_ptr<flutter::EmbedderExternalViewEmbedder>
        external_view_embedder) {
  if (config->type != kOpenGL) {
    return nullptr;
  }

  auto gl_make_current = [ptr = config->open_gl.make_current,
                          user_data]() -> bool { return ptr(user_data); };

  auto gl_clear_current = [ptr = config->open_gl.clear_current,
                           user_data]() -> bool { return ptr(user_data); };

  auto gl_present = [present = config->open_gl.present,
                     present_with_info = config->open_gl.present_with_info,
                     user_data](uint32_t fbo_id) -> bool {
    if (present) {
      return present(user_data);
    } else {
      FlutterPresentInfo present_info = {};
      present_info.struct_size = sizeof(FlutterPresentInfo);
      present_info.fbo_id = fbo_id;
      return present_with_info(user_data, &present_info);
    }
  };

  auto gl_fbo_callback =
      [fbo_callback = config->open_gl.fbo_callback,
       fbo_with_frame_info_callback =
           config->open_gl.fbo_with_frame_info_callback,
       user_data](flutter::GLFrameInfo gl_frame_info) -> intptr_t {
    if (fbo_callback) {
      return fbo_callback(user_data);
    } else {
      FlutterFrameInfo frame_info = {};
      frame_info.struct_size = sizeof(FlutterFrameInfo);
      frame_info.size = {gl_frame_info.width, gl_frame_info.height};
      return fbo_with_frame_info_callback(user_data, &frame_info);
    }
  };

  const FlutterOpenGLRendererConfig* open_gl_config = &config->open_gl;
  std::function<bool()> gl_make_resource_current_callback = nullptr;
  if (SAFE_ACCESS(open_gl_config, make_resource_current, nullptr) != nullptr) {
    gl_make_resource_current_callback =
        [ptr = config->open_gl.make_resource_current, user_data]() {
          return ptr(user_data);
        };
  }

  std::function<SkMatrix(void)> gl_surface_transformation_callback = nullptr;
  if (SAFE_ACCESS(open_gl_config, surface_transformation, nullptr) != nullptr) {
    gl_surface_transformation_callback =
        [ptr = config->open_gl.surface_transformation, user_data]() {
          FlutterTransformation transformation = ptr(user_data);
          return SkMatrix::MakeAll(transformation.scaleX,  //
                                   transformation.skewX,   //
                                   transformation.transX,  //
                                   transformation.skewY,   //
                                   transformation.scaleY,  //
                                   transformation.transY,  //
                                   transformation.pers0,   //
                                   transformation.pers1,   //
                                   transformation.pers2    //
          );
        };

    // If there is an external view embedder, ask it to apply the surface
    // transformation to its surfaces as well.
    if (external_view_embedder) {
      external_view_embedder->SetSurfaceTransformationCallback(
          gl_surface_transformation_callback);
    }
  }

  flutter::GPUSurfaceGLDelegate::GLProcResolver gl_proc_resolver = nullptr;
  if (SAFE_ACCESS(open_gl_config, gl_proc_resolver, nullptr) != nullptr) {
    gl_proc_resolver = [ptr = config->open_gl.gl_proc_resolver,
                        user_data](const char* gl_proc_name) {
      return ptr(user_data, gl_proc_name);
    };
  } else {
#if OS_LINUX || OS_WIN
    gl_proc_resolver = DefaultGLProcResolver;
#endif
  }

  bool fbo_reset_after_present =
      SAFE_ACCESS(open_gl_config, fbo_reset_after_present, false);

  flutter::EmbedderSurfaceGL::GLDispatchTable gl_dispatch_table = {
      gl_make_current,                     // gl_make_current_callback
      gl_clear_current,                    // gl_clear_current_callback
      gl_present,                          // gl_present_callback
      gl_fbo_callback,                     // gl_fbo_callback
      gl_make_resource_current_callback,   // gl_make_resource_current_callback
      gl_surface_transformation_callback,  // gl_surface_transformation_callback
      gl_proc_resolver,                    // gl_proc_resolver
  };

  return fml::MakeCopyable(
      [gl_dispatch_table, fbo_reset_after_present, platform_dispatch_table,
       external_view_embedder =
           std::move(external_view_embedder)](flutter::Shell& shell) mutable {
        return std::make_unique<flutter::PlatformViewEmbedder>(
            shell,                    // delegate
            shell.GetTaskRunners(),   // task runners
            gl_dispatch_table,        // embedder GL dispatch table
            fbo_reset_after_present,  // fbo reset after present
            platform_dispatch_table,  // embedder platform dispatch table
            std::move(external_view_embedder)  // external view embedder
        );
      });
}

static flutter::Shell::CreateCallback<flutter::PlatformView>
InferSoftwarePlatformViewCreationCallback(
    const FlutterRendererConfig* config,
    void* user_data,
    flutter::PlatformViewEmbedder::PlatformDispatchTable
        platform_dispatch_table,
    std::unique_ptr<flutter::EmbedderExternalViewEmbedder>
        external_view_embedder) {
  if (config->type != kSoftware) {
    return nullptr;
  }

  auto software_present_backing_store =
      [ptr = config->software.surface_present_callback, user_data](
          const void* allocation, size_t row_bytes, size_t height) -> bool {
    return ptr(user_data, allocation, row_bytes, height);
  };

  flutter::EmbedderSurfaceSoftware::SoftwareDispatchTable
      software_dispatch_table = {
          software_present_backing_store,  // required
      };

  return fml::MakeCopyable(
      [software_dispatch_table, platform_dispatch_table,
       external_view_embedder =
           std::move(external_view_embedder)](flutter::Shell& shell) mutable {
        return std::make_unique<flutter::PlatformViewEmbedder>(
            shell,                             // delegate
            shell.GetTaskRunners(),            // task runners
            software_dispatch_table,           // software dispatch table
            platform_dispatch_table,           // platform dispatch table
            std::move(external_view_embedder)  // external view embedder
        );
      });
}

static flutter::Shell::CreateCallback<flutter::PlatformView>
InferPlatformViewCreationCallback(
    const FlutterRendererConfig* config,
    void* user_data,
    flutter::PlatformViewEmbedder::PlatformDispatchTable
        platform_dispatch_table,
    std::unique_ptr<flutter::EmbedderExternalViewEmbedder>
        external_view_embedder) {
  if (config == nullptr) {
    return nullptr;
  }

  switch (config->type) {
    case kOpenGL:
      return InferOpenGLPlatformViewCreationCallback(
          config, user_data, platform_dispatch_table,
          std::move(external_view_embedder));
    case kSoftware:
      return InferSoftwarePlatformViewCreationCallback(
          config, user_data, platform_dispatch_table,
          std::move(external_view_embedder));
    default:
      return nullptr;
  }
  return nullptr;
}

static sk_sp<SkSurface> MakeSkSurfaceFromBackingStore(
    GrDirectContext* context,
    const FlutterBackingStoreConfig& config,
    const FlutterOpenGLTexture* texture) {
  GrGLTextureInfo texture_info;
  texture_info.fTarget = texture->target;
  texture_info.fID = texture->name;
  texture_info.fFormat = texture->format;

  GrBackendTexture backend_texture(config.size.width,   //
                                   config.size.height,  //
                                   GrMipMapped::kNo,    //
                                   texture_info         //
  );

  SkSurfaceProps surface_properties(
      SkSurfaceProps::InitType::kLegacyFontHost_InitType);

  auto surface = SkSurface::MakeFromBackendTexture(
      context,                      // context
      backend_texture,              // back-end texture
      kBottomLeft_GrSurfaceOrigin,  // surface origin
      1,                            // sample count
      kN32_SkColorType,             // color type
      SkColorSpace::MakeSRGB(),     // color space
      &surface_properties,          // surface properties
      static_cast<SkSurface::TextureReleaseProc>(
          texture->destruction_callback),  // release proc
      texture->user_data                   // release context
  );

  if (!surface) {
    FML_LOG(ERROR) << ""Could not wrap embedder supplied render texture."";
    texture->destruction_callback(texture->user_data);
    return nullptr;
  }

  return surface;
}

static sk_sp<SkSurface> MakeSkSurfaceFromBackingStore(
    GrDirectContext* context,
    const FlutterBackingStoreConfig& config,
    const FlutterOpenGLFramebuffer* framebuffer) {
  GrGLFramebufferInfo framebuffer_info = {};
  framebuffer_info.fFormat = framebuffer->target;
  framebuffer_info.fFBOID = framebuffer->name;

  GrBackendRenderTarget backend_render_target(
      config.size.width,   // width
      config.size.height,  // height
      1,                   // sample count
      0,                   // stencil bits
      framebuffer_info     // framebuffer info
  );

  SkSurfaceProps surface_properties(
      SkSurfaceProps::InitType::kLegacyFontHost_InitType);

  auto surface = SkSurface::MakeFromBackendRenderTarget(
      context,                      //  context
      backend_render_target,        // backend render target
      kBottomLeft_GrSurfaceOrigin,  // surface origin
      kN32_SkColorType,             // color type
      SkColorSpace::MakeSRGB(),     // color space
      &surface_properties,          // surface properties
      static_cast<SkSurface::RenderTargetReleaseProc>(
          framebuffer->destruction_callback),  // release proc
      framebuffer->user_data                   // release context
  );

  if (!surface) {
    FML_LOG(ERROR) << ""Could not wrap embedder supplied frame-buffer."";
    framebuffer->destruction_callback(framebuffer->user_data);
    return nullptr;
  }
  return surface;
}

static sk_sp<SkSurface> MakeSkSurfaceFromBackingStore(
    GrDirectContext* context,
    const FlutterBackingStoreConfig& config,
    const FlutterSoftwareBackingStore* software) {
  const auto image_info =
      SkImageInfo::MakeN32Premul(config.size.width, config.size.height);

  struct Captures {
    VoidCallback destruction_callback;
    void* user_data;
  };
  auto captures = std::make_unique<Captures>();
  captures->destruction_callback = software->destruction_callback;
  captures->user_data = software->user_data;
  auto release_proc = [](void* pixels, void* context) {
    auto captures = reinterpret_cast<Captures*>(context);
    captures->destruction_callback(captures->user_data);
  };

  auto surface = SkSurface::MakeRasterDirectReleaseProc(
      image_info,                               // image info
      const_cast<void*>(software->allocation),  // pixels
      software->row_bytes,                      // row bytes
      release_proc,                             // release proc
      captures.release()                        // release context
  );

  if (!surface) {
    FML_LOG(ERROR)
        << ""Could not wrap embedder supplied software render buffer."";
    software->destruction_callback(software->user_data);
    return nullptr;
  }
  return surface;
}

static std::unique_ptr<flutter::EmbedderRenderTarget>
CreateEmbedderRenderTarget(const FlutterCompositor* compositor,
                           const FlutterBackingStoreConfig& config,
                           GrDirectContext* context) {
  FlutterBackingStore backing_store = {};
  backing_store.struct_size = sizeof(backing_store);

  // Safe access checks on the compositor struct have been performed in
  // InferExternalViewEmbedderFromArgs and are not necessary here.
  auto c_create_callback = compositor->create_backing_store_callback;
  auto c_collect_callback = compositor->collect_backing_store_callback;

  {
    TRACE_EVENT0(""flutter"", ""FlutterCompositorCreateBackingStore"");
    if (!c_create_callback(&config, &backing_store, compositor->user_data)) {
      FML_LOG(ERROR) << ""Could not create the embedder backing store."";
      return nullptr;
    }
  }

  if (backing_store.struct_size != sizeof(backing_store)) {
    FML_LOG(ERROR) << ""Embedder modified the backing store struct size."";
    return nullptr;
  }

  // In case we return early without creating an embedder render target, the
  // embedder has still given us ownership of its baton which we must return
  // back to it. If this method is successful, the closure is released when the
  // render target is eventually released.
  fml::ScopedCleanupClosure collect_callback(
      [c_collect_callback, backing_store, user_data = compositor->user_data]() {
        TRACE_EVENT0(""flutter"", ""FlutterCompositorCollectBackingStore"");
        c_collect_callback(&backing_store, user_data);
      });

  // No safe access checks on the renderer are necessary since we allocated
  // the struct.

  sk_sp<SkSurface> render_surface;

  switch (backing_store.type) {
    case kFlutterBackingStoreTypeOpenGL:
      switch (backing_store.open_gl.type) {
        case kFlutterOpenGLTargetTypeTexture:
          render_surface = MakeSkSurfaceFromBackingStore(
              context, config, &backing_store.open_gl.texture);
          break;
        case kFlutterOpenGLTargetTypeFramebuffer:
          render_surface = MakeSkSurfaceFromBackingStore(
              context, config, &backing_store.open_gl.framebuffer);
          break;
      }
      break;
    case kFlutterBackingStoreTypeSoftware:
      render_surface = MakeSkSurfaceFromBackingStore(context, config,
                                                     &backing_store.software);
      break;
  };

  if (!render_surface) {
    FML_LOG(ERROR) << ""Could not create a surface from an embedder provided ""
                      ""render target."";
    return nullptr;
  }

  return std::make_unique<flutter::EmbedderRenderTarget>(
      backing_store, std::move(render_surface), collect_callback.Release());
}

static std::pair<std::unique_ptr<flutter::EmbedderExternalViewEmbedder>,
                 bool /* halt engine launch if true */>
InferExternalViewEmbedderFromArgs(const FlutterCompositor* compositor) {
  if (compositor == nullptr) {
    return {nullptr, false};
  }

  auto c_create_callback =
      SAFE_ACCESS(compositor, create_backing_store_callback, nullptr);
  auto c_collect_callback =
      SAFE_ACCESS(compositor, collect_backing_store_callback, nullptr);
  auto c_present_callback =
      SAFE_ACCESS(compositor, present_layers_callback, nullptr);

  // Make sure the required callbacks are present
  if (!c_create_callback || !c_collect_callback || !c_present_callback) {
    FML_LOG(ERROR) << ""Required compositor callbacks absent."";
    return {nullptr, true};
  }

  FlutterCompositor captured_compositor = *compositor;

  flutter::EmbedderExternalViewEmbedder::CreateRenderTargetCallback
      create_render_target_callback =
          [captured_compositor](GrDirectContext* context, const auto& config) {
            return CreateEmbedderRenderTarget(&captured_compositor, config,
                                              context);
          };

  flutter::EmbedderExternalViewEmbedder::PresentCallback present_callback =
      [c_present_callback,
       user_data = compositor->user_data](const auto& layers) {
        TRACE_EVENT0(""flutter"", ""FlutterCompositorPresentLayers"");
        return c_present_callback(
            const_cast<const FlutterLayer**>(layers.data()), layers.size(),
            user_data);
      };

  return {std::make_unique<flutter::EmbedderExternalViewEmbedder>(
              create_render_target_callback, present_callback),
          false};
}

struct _FlutterPlatformMessageResponseHandle {
  fml::RefPtr<flutter::PlatformMessage> message;
};

struct LoadedElfDeleter {
  void operator()(Dart_LoadedElf* elf) {
    if (elf) {
      ::Dart_UnloadELF(elf);
    }
  }
};

using UniqueLoadedElf = std::unique_ptr<Dart_LoadedElf, LoadedElfDeleter>;

struct _FlutterEngineAOTData {
  UniqueLoadedElf loaded_elf = nullptr;
  const uint8_t* vm_snapshot_data = nullptr;
  const uint8_t* vm_snapshot_instrs = nullptr;
  const uint8_t* vm_isolate_data = nullptr;
  const uint8_t* vm_isolate_instrs = nullptr;
};

FlutterEngineResult FlutterEngineCreateAOTData(
    const FlutterEngineAOTDataSource* source,
    FlutterEngineAOTData* data_out) {
  if (!flutter::DartVM::IsRunningPrecompiledCode()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""AOT data can only be created in AOT mode."");
  } else if (!source) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Null source specified."");
  } else if (!data_out) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Null data_out specified."");
  }

  switch (source->type) {
    case kFlutterEngineAOTDataSourceTypeElfPath: {
      if (!source->elf_path || !fml::IsFile(source->elf_path)) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  ""Invalid ELF path specified."");
      }

      auto aot_data = std::make_unique<_FlutterEngineAOTData>();
      const char* error = nullptr;

      Dart_LoadedElf* loaded_elf = Dart_LoadELF(
          source->elf_path,               // file path
          0,                              // file offset
          &error,                         // error (out)
          &aot_data->vm_snapshot_data,    // vm snapshot data (out)
          &aot_data->vm_snapshot_instrs,  // vm snapshot instr (out)
          &aot_data->vm_isolate_data,     // vm isolate data (out)
          &aot_data->vm_isolate_instrs    // vm isolate instr (out)
      );

      if (loaded_elf == nullptr) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments, error);
      }

      aot_data->loaded_elf.reset(loaded_elf);

      *data_out = aot_data.release();
      return kSuccess;
    }
  }

  return LOG_EMBEDDER_ERROR(
      kInvalidArguments,
      ""Invalid FlutterEngineAOTDataSourceType type specified."");
}

FlutterEngineResult FlutterEngineCollectAOTData(FlutterEngineAOTData data) {
  if (data) {
    data->loaded_elf = nullptr;
    data->vm_snapshot_data = nullptr;
    data->vm_snapshot_instrs = nullptr;
    data->vm_isolate_data = nullptr;
    data->vm_isolate_instrs = nullptr;
  }
  return kSuccess;
}

void PopulateSnapshotMappingCallbacks(const FlutterProjectArgs* args,
                                      flutter::Settings& settings) {
  // There are no ownership concerns here as all mappings are owned by the
  // embedder and not the engine.
  auto make_mapping_callback = [](const uint8_t* mapping, size_t size) {
    return [mapping, size]() {
      return std::make_unique<fml::NonOwnedMapping>(mapping, size);
    };
  };

  if (flutter::DartVM::IsRunningPrecompiledCode()) {
    if (SAFE_ACCESS(args, aot_data, nullptr) != nullptr) {
      settings.vm_snapshot_data =
          make_mapping_callback(args->aot_data->vm_snapshot_data, 0);

      settings.vm_snapshot_instr =
          make_mapping_callback(args->aot_data->vm_snapshot_instrs, 0);

      settings.isolate_snapshot_data =
          make_mapping_callback(args->aot_data->vm_isolate_data, 0);

      settings.isolate_snapshot_instr =
          make_mapping_callback(args->aot_data->vm_isolate_instrs, 0);
    }

    if (SAFE_ACCESS(args, vm_snapshot_data, nullptr) != nullptr) {
      settings.vm_snapshot_data = make_mapping_callback(
          args->vm_snapshot_data, SAFE_ACCESS(args, vm_snapshot_data_size, 0));
    }

    if (SAFE_ACCESS(args, vm_snapshot_instructions, nullptr) != nullptr) {
      settings.vm_snapshot_instr = make_mapping_callback(
          args->vm_snapshot_instructions,
          SAFE_ACCESS(args, vm_snapshot_instructions_size, 0));
    }

    if (SAFE_ACCESS(args, isolate_snapshot_data, nullptr) != nullptr) {
      settings.isolate_snapshot_data = make_mapping_callback(
          args->isolate_snapshot_data,
          SAFE_ACCESS(args, isolate_snapshot_data_size, 0));
    }

    if (SAFE_ACCESS(args, isolate_snapshot_instructions, nullptr) != nullptr) {
      settings.isolate_snapshot_instr = make_mapping_callback(
          args->isolate_snapshot_instructions,
          SAFE_ACCESS(args, isolate_snapshot_instructions_size, 0));
    }
  }

#if !OS_FUCHSIA && (FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG)
  settings.dart_library_sources_kernel =
      make_mapping_callback(kPlatformStrongDill, kPlatformStrongDillSize);
#endif  // !OS_FUCHSIA && (FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG)
}

FlutterEngineResult FlutterEngineRun(size_t version,
                                     const FlutterRendererConfig* config,
                                     const FlutterProjectArgs* args,
                                     void* user_data,
                                     FLUTTER_API_SYMBOL(FlutterEngine) *
                                         engine_out) {
  auto result =
      FlutterEngineInitialize(version, config, args, user_data, engine_out);

  if (result != kSuccess) {
    return result;
  }

  return FlutterEngineRunInitialized(*engine_out);
}

FlutterEngineResult FlutterEngineInitialize(size_t version,
                                            const FlutterRendererConfig* config,
                                            const FlutterProjectArgs* args,
                                            void* user_data,
                                            FLUTTER_API_SYMBOL(FlutterEngine) *
                                                engine_out) {
  // Step 0: Figure out arguments for shell creation.
  if (version != FLUTTER_ENGINE_VERSION) {
    return LOG_EMBEDDER_ERROR(
        kInvalidLibraryVersion,
        ""Flutter embedder version mismatch. There has been a breaking change. ""
        ""Please consult the changelog and update the embedder."");
  }

  if (engine_out == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""The engine out parameter was missing."");
  }

  if (args == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""The Flutter project arguments were missing."");
  }

  if (SAFE_ACCESS(args, assets_path, nullptr) == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""The assets path in the Flutter project arguments was missing."");
  }

  if (SAFE_ACCESS(args, main_path__unused__, nullptr) != nullptr) {
    FML_LOG(WARNING)
        << ""FlutterProjectArgs.main_path is deprecated and should be set null."";
  }

  if (SAFE_ACCESS(args, packages_path__unused__, nullptr) != nullptr) {
    FML_LOG(WARNING) << ""FlutterProjectArgs.packages_path is deprecated and ""
                        ""should be set null."";
  }

  if (!IsRendererValid(config)) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""The renderer configuration was invalid."");
  }

  std::string icu_data_path;
  if (SAFE_ACCESS(args, icu_data_path, nullptr) != nullptr) {
    icu_data_path = SAFE_ACCESS(args, icu_data_path, nullptr);
  }

  if (SAFE_ACCESS(args, persistent_cache_path, nullptr) != nullptr) {
    std::string persistent_cache_path =
        SAFE_ACCESS(args, persistent_cache_path, nullptr);
    flutter::PersistentCache::SetCacheDirectoryPath(persistent_cache_path);
  }

  if (SAFE_ACCESS(args, is_persistent_cache_read_only, false)) {
    flutter::PersistentCache::gIsReadOnly = true;
  }

  fml::CommandLine command_line;
  if (SAFE_ACCESS(args, command_line_argc, 0) != 0 &&
      SAFE_ACCESS(args, command_line_argv, nullptr) != nullptr) {
    command_line = fml::CommandLineFromArgcArgv(
        SAFE_ACCESS(args, command_line_argc, 0),
        SAFE_ACCESS(args, command_line_argv, nullptr));
  }

  flutter::Settings settings = flutter::SettingsFromCommandLine(command_line);

  if (SAFE_ACCESS(args, aot_data, nullptr)) {
    if (SAFE_ACCESS(args, vm_snapshot_data, nullptr) ||
        SAFE_ACCESS(args, vm_snapshot_instructions, nullptr) ||
        SAFE_ACCESS(args, isolate_snapshot_data, nullptr) ||
        SAFE_ACCESS(args, isolate_snapshot_instructions, nullptr)) {
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          ""Multiple AOT sources specified. Embedders should provide either ""
          ""*_snapshot_* buffers or aot_data, not both."");
    }
  }

  PopulateSnapshotMappingCallbacks(args, settings);

  settings.icu_data_path = icu_data_path;
  settings.assets_path = args->assets_path;
  settings.leak_vm = !SAFE_ACCESS(args, shutdown_dart_vm_when_done, false);
  settings.old_gen_heap_size = SAFE_ACCESS(args, dart_old_gen_heap_size, -1);

  if (!flutter::DartVM::IsRunningPrecompiledCode()) {
    // Verify the assets path contains Dart 2 kernel assets.
    const std::string kApplicationKernelSnapshotFileName = ""kernel_blob.bin"";
    std::string application_kernel_path = fml::paths::JoinPaths(
        {settings.assets_path, kApplicationKernelSnapshotFileName});
    if (!fml::IsFile(application_kernel_path)) {
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          ""Not running in AOT mode but could not resolve the kernel binary."");
    }
    settings.application_kernel_asset = kApplicationKernelSnapshotFileName;
  }

  settings.task_observer_add = [](intptr_t key, fml::closure callback) {
    fml::MessageLoop::GetCurrent().AddTaskObserver(key, std::move(callback));
  };
  settings.task_observer_remove = [](intptr_t key) {
    fml::MessageLoop::GetCurrent().RemoveTaskObserver(key);
  };
  if (SAFE_ACCESS(args, root_isolate_create_callback, nullptr) != nullptr) {
    VoidCallback callback =
        SAFE_ACCESS(args, root_isolate_create_callback, nullptr);
    settings.root_isolate_create_callback = [callback, user_data]() {
      callback(user_data);
    };
  }

  flutter::PlatformViewEmbedder::UpdateSemanticsNodesCallback
      update_semantics_nodes_callback = nullptr;
  if (SAFE_ACCESS(args, update_semantics_node_callback, nullptr) != nullptr) {
    update_semantics_nodes_callback =
        [ptr = args->update_semantics_node_callback,
         user_data](flutter::SemanticsNodeUpdates update) {
          for (const auto& value : update) {
            const auto& node = value.second;
            SkMatrix transform = node.transform.asM33();
            FlutterTransformation flutter_transform{
                transform.get(SkMatrix::kMScaleX),
                transform.get(SkMatrix::kMSkewX),
                transform.get(SkMatrix::kMTransX),
                transform.get(SkMatrix::kMSkewY),
                transform.get(SkMatrix::kMScaleY),
                transform.get(SkMatrix::kMTransY),
                transform.get(SkMatrix::kMPersp0),
                transform.get(SkMatrix::kMPersp1),
                transform.get(SkMatrix::kMPersp2)};
            const FlutterSemanticsNode embedder_node{
                sizeof(FlutterSemanticsNode),
                node.id,
                static_cast<FlutterSemanticsFlag>(node.flags),
                static_cast<FlutterSemanticsAction>(node.actions),
                node.textSelectionBase,
                node.textSelectionExtent,
                node.scrollChildren,
                node.scrollIndex,
                node.scrollPosition,
                node.scrollExtentMax,
                node.scrollExtentMin,
                node.elevation,
                node.thickness,
                node.label.c_str(),
                node.hint.c_str(),
                node.value.c_str(),
                node.increasedValue.c_str(),
                node.decreasedValue.c_str(),
                static_cast<FlutterTextDirection>(node.textDirection),
                FlutterRect{node.rect.fLeft, node.rect.fTop, node.rect.fRight,
                            node.rect.fBottom},
                flutter_transform,
                node.childrenInTraversalOrder.size(),
                &node.childrenInTraversalOrder[0],
                &node.childrenInHitTestOrder[0],
                node.customAccessibilityActions.size(),
                &node.customAccessibilityActions[0],
                node.platformViewId,
            };
            ptr(&embedder_node, user_data);
          }
          const FlutterSemanticsNode batch_end_sentinel = {
              sizeof(FlutterSemanticsNode),
              kFlutterSemanticsNodeIdBatchEnd,
          };
          ptr(&batch_end_sentinel, user_data);
        };
  }

  flutter::PlatformViewEmbedder::UpdateSemanticsCustomActionsCallback
      update_semantics_custom_actions_callback = nullptr;
  if (SAFE_ACCESS(args, update_semantics_custom_action_callback, nullptr) !=
      nullptr) {
    update_semantics_custom_actions_callback =
        [ptr = args->update_semantics_custom_action_callback,
         user_data](flutter::CustomAccessibilityActionUpdates actions) {
          for (const auto& value : actions) {
            const auto& action = value.second;
            const FlutterSemanticsCustomAction embedder_action = {
                sizeof(FlutterSemanticsCustomAction),
                action.id,
                static_cast<FlutterSemanticsAction>(action.overrideId),
                action.label.c_str(),
                action.hint.c_str(),
            };
            ptr(&embedder_action, user_data);
          }
          const FlutterSemanticsCustomAction batch_end_sentinel = {
              sizeof(FlutterSemanticsCustomAction),
              kFlutterSemanticsCustomActionIdBatchEnd,
          };
          ptr(&batch_end_sentinel, user_data);
        };
  }

  flutter::PlatformViewEmbedder::PlatformMessageResponseCallback
      platform_message_response_callback = nullptr;
  if (SAFE_ACCESS(args, platform_message_callback, nullptr) != nullptr) {
    platform_message_response_callback =
        [ptr = args->platform_message_callback,
         user_data](fml::RefPtr<flutter::PlatformMessage> message) {
          auto handle = new FlutterPlatformMessageResponseHandle();
          const FlutterPlatformMessage incoming_message = {
              sizeof(FlutterPlatformMessage),  // struct_size
              message->channel().c_str(),      // channel
              message->data().data(),          // message
              message->data().size(),          // message_size
              handle,                          // response_handle
          };
          handle->message = std::move(message);
          return ptr(&incoming_message, user_data);
        };
  }

  flutter::VsyncWaiterEmbedder::VsyncCallback vsync_callback = nullptr;
  if (SAFE_ACCESS(args, vsync_callback, nullptr) != nullptr) {
    vsync_callback = [ptr = args->vsync_callback, user_data](intptr_t baton) {
      return ptr(user_data, baton);
    };
  }

  flutter::PlatformViewEmbedder::ComputePlatformResolvedLocaleCallback
      compute_platform_resolved_locale_callback = nullptr;
  if (SAFE_ACCESS(args, compute_platform_resolved_locale_callback, nullptr) !=
      nullptr) {
    compute_platform_resolved_locale_callback =
        [ptr = args->compute_platform_resolved_locale_callback](
            const std::vector<std::string>& supported_locales_data) {
          const size_t number_of_strings_per_locale = 3;
          size_t locale_count =
              supported_locales_data.size() / number_of_strings_per_locale;
          std::vector<FlutterLocale> supported_locales;
          std::vector<const FlutterLocale*> supported_locales_ptr;
          for (size_t i = 0; i < locale_count; ++i) {
            supported_locales.push_back(
                {.struct_size = sizeof(FlutterLocale),
                 .language_code =
                     supported_locales_data[i * number_of_strings_per_locale +
                                            0]
                         .c_str(),
                 .country_code =
                     supported_locales_data[i * number_of_strings_per_locale +
                                            1]
                         .c_str(),
                 .script_code =
                     supported_locales_data[i * number_of_strings_per_locale +
                                            2]
                         .c_str(),
                 .variant_code = nullptr});
            supported_locales_ptr.push_back(&supported_locales[i]);
          }

          const FlutterLocale* result =
              ptr(supported_locales_ptr.data(), locale_count);

          std::unique_ptr<std::vector<std::string>> out =
              std::make_unique<std::vector<std::string>>();
          if (result) {
            std::string language_code(SAFE_ACCESS(result, language_code, """"));
            if (language_code != """") {
              out->push_back(language_code);
              out->emplace_back(SAFE_ACCESS(result, country_code, """"));
              out->emplace_back(SAFE_ACCESS(result, script_code, """"));
            }
          }
          return out;
        };
  }

  auto external_view_embedder_result =
      InferExternalViewEmbedderFromArgs(SAFE_ACCESS(args, compositor, nullptr));
  if (external_view_embedder_result.second) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Compositor arguments were invalid."");
  }

  flutter::PlatformViewEmbedder::PlatformDispatchTable platform_dispatch_table =
      {
          update_semantics_nodes_callback,            //
          update_semantics_custom_actions_callback,   //
          platform_message_response_callback,         //
          vsync_callback,                             //
          compute_platform_resolved_locale_callback,  //
      };

  auto on_create_platform_view = InferPlatformViewCreationCallback(
      config, user_data, platform_dispatch_table,
      std::move(external_view_embedder_result.first));

  if (!on_create_platform_view) {
    return LOG_EMBEDDER_ERROR(
        kInternalInconsistency,
        ""Could not infer platform view creation callback."");
  }

  flutter::Shell::CreateCallback<flutter::Rasterizer> on_create_rasterizer =
      [](flutter::Shell& shell) {
        return std::make_unique<flutter::Rasterizer>(shell);
      };

  // TODO(chinmaygarde): This is the wrong spot for this. It belongs in the
  // platform view jump table.
  flutter::EmbedderExternalTextureGL::ExternalTextureCallback
      external_texture_callback;
  if (config->type == kOpenGL) {
    const FlutterOpenGLRendererConfig* open_gl_config = &config->open_gl;
    if (SAFE_ACCESS(open_gl_config, gl_external_texture_frame_callback,
                    nullptr) != nullptr) {
      external_texture_callback =
          [ptr = open_gl_config->gl_external_texture_frame_callback, user_data](
              int64_t texture_identifier, GrDirectContext* context,
              const SkISize& size) -> sk_sp<SkImage> {
        FlutterOpenGLTexture texture = {};

        if (!ptr(user_data, texture_identifier, size.width(), size.height(),
                 &texture)) {
          return nullptr;
        }

        GrGLTextureInfo gr_texture_info = {texture.target, texture.name,
                                           texture.format};

        size_t width = size.width();
        size_t height = size.height();

        if (texture.width != 0 && texture.height != 0) {
          width = texture.width;
          height = texture.height;
        }

        GrBackendTexture gr_backend_texture(width, height, GrMipMapped::kNo,
                                            gr_texture_info);
        SkImage::TextureReleaseProc release_proc = texture.destruction_callback;
        auto image = SkImage::MakeFromTexture(
            context,                   // context
            gr_backend_texture,        // texture handle
            kTopLeft_GrSurfaceOrigin,  // origin
            kRGBA_8888_SkColorType,    // color type
            kPremul_SkAlphaType,       // alpha type
            nullptr,                   // colorspace
            release_proc,              // texture release proc
            texture.user_data          // texture release context
        );

        if (!image) {
          // In case Skia rejects the image, call the release proc so that
          // embedders can perform collection of intermediates.
          if (release_proc) {
            release_proc(texture.user_data);
          }
          FML_LOG(ERROR) << ""Could not create external texture."";
          return nullptr;
        }

        return image;
      };
    }
  }

  auto thread_host =
      flutter::EmbedderThreadHost::CreateEmbedderOrEngineManagedThreadHost(
          SAFE_ACCESS(args, custom_task_runners, nullptr));

  if (!thread_host || !thread_host->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Could not setup or infer thread configuration ""
                              ""to run the Flutter engine on."");
  }

  auto task_runners = thread_host->GetTaskRunners();

  if (!task_runners.IsValid()) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Task runner configuration was invalid."");
  }

  auto run_configuration =
      flutter::RunConfiguration::InferFromSettings(settings);

  if (SAFE_ACCESS(args, custom_dart_entrypoint, nullptr) != nullptr) {
    auto dart_entrypoint = std::string{args->custom_dart_entrypoint};
    if (dart_entrypoint.size() != 0) {
      run_configuration.SetEntrypoint(std::move(dart_entrypoint));
    }
  }

  if (!run_configuration.IsValid()) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""Could not infer the Flutter project to run from given arguments."");
  }

  // Create the engine but don't launch the shell or run the root isolate.
  auto embedder_engine = std::make_unique<flutter::EmbedderEngine>(
      std::move(thread_host),        //
      std::move(task_runners),       //
      std::move(settings),           //
      std::move(run_configuration),  //
      on_create_platform_view,       //
      on_create_rasterizer,          //
      external_texture_callback      //
  );

  // Release the ownership of the embedder engine to the caller.
  *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(
      embedder_engine.release());
  return kSuccess;
}

FlutterEngineResult FlutterEngineRunInitialized(
    FLUTTER_API_SYMBOL(FlutterEngine) engine) {
  if (!engine) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);

  // The engine must not already be running. Initialize may only be called
  // once on an engine instance.
  if (embedder_engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  // Step 1: Launch the shell.
  if (!embedder_engine->LaunchShell()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Could not launch the engine using supplied ""
                              ""initialization arguments."");
  }

  // Step 2: Tell the platform view to initialize itself.
  if (!embedder_engine->NotifyCreated()) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not create platform view components."");
  }

  // Step 3: Launch the root isolate.
  if (!embedder_engine->RunRootIsolate()) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""Could not run the root isolate of the Flutter application using the ""
        ""project arguments specified."");
  }

  return kSuccess;
}

FLUTTER_EXPORT
FlutterEngineResult FlutterEngineDeinitialize(FLUTTER_API_SYMBOL(FlutterEngine)
                                                  engine) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  embedder_engine->NotifyDestroyed();
  embedder_engine->CollectShell();
  return kSuccess;
}

FlutterEngineResult FlutterEngineShutdown(FLUTTER_API_SYMBOL(FlutterEngine)
                                              engine) {
  auto result = FlutterEngineDeinitialize(engine);
  if (result != kSuccess) {
    return result;
  }
  auto embedder_engine = reinterpret_cast<flutter::EmbedderEngine*>(engine);
  delete embedder_engine;
  return kSuccess;
}

FlutterEngineResult FlutterEngineSendWindowMetricsEvent(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    const FlutterWindowMetricsEvent* flutter_metrics) {
  if (engine == nullptr || flutter_metrics == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  flutter::ViewportMetrics metrics;

  metrics.physical_width = SAFE_ACCESS(flutter_metrics, width, 0.0);
  metrics.physical_height = SAFE_ACCESS(flutter_metrics, height, 0.0);
  metrics.device_pixel_ratio = SAFE_ACCESS(flutter_metrics, pixel_ratio, 1.0);

  if (metrics.device_pixel_ratio <= 0.0) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""Device pixel ratio was invalid. It must be greater than zero."");
  }

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)->SetViewportMetrics(
             std::move(metrics))
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  ""Viewport metrics were invalid."");
}

// Returns the flutter::PointerData::Change for the given FlutterPointerPhase.
inline flutter::PointerData::Change ToPointerDataChange(
    FlutterPointerPhase phase) {
  switch (phase) {
    case kCancel:
      return flutter::PointerData::Change::kCancel;
    case kUp:
      return flutter::PointerData::Change::kUp;
    case kDown:
      return flutter::PointerData::Change::kDown;
    case kMove:
      return flutter::PointerData::Change::kMove;
    case kAdd:
      return flutter::PointerData::Change::kAdd;
    case kRemove:
      return flutter::PointerData::Change::kRemove;
    case kHover:
      return flutter::PointerData::Change::kHover;
  }
  return flutter::PointerData::Change::kCancel;
}

// Returns the flutter::PointerData::DeviceKind for the given
// FlutterPointerDeviceKind.
inline flutter::PointerData::DeviceKind ToPointerDataKind(
    FlutterPointerDeviceKind device_kind) {
  switch (device_kind) {
    case kFlutterPointerDeviceKindMouse:
      return flutter::PointerData::DeviceKind::kMouse;
    case kFlutterPointerDeviceKindTouch:
      return flutter::PointerData::DeviceKind::kTouch;
  }
  return flutter::PointerData::DeviceKind::kMouse;
}

// Returns the flutter::PointerData::SignalKind for the given
// FlutterPointerSignaKind.
inline flutter::PointerData::SignalKind ToPointerDataSignalKind(
    FlutterPointerSignalKind kind) {
  switch (kind) {
    case kFlutterPointerSignalKindNone:
      return flutter::PointerData::SignalKind::kNone;
    case kFlutterPointerSignalKindScroll:
      return flutter::PointerData::SignalKind::kScroll;
  }
  return flutter::PointerData::SignalKind::kNone;
}

// Returns the buttons to synthesize for a PointerData from a
// FlutterPointerEvent with no type or buttons set.
inline int64_t PointerDataButtonsForLegacyEvent(
    flutter::PointerData::Change change) {
  switch (change) {
    case flutter::PointerData::Change::kDown:
    case flutter::PointerData::Change::kMove:
      // These kinds of change must have a non-zero `buttons`, otherwise
      // gesture recognizers will ignore these events.
      return flutter::kPointerButtonMousePrimary;
    case flutter::PointerData::Change::kCancel:
    case flutter::PointerData::Change::kAdd:
    case flutter::PointerData::Change::kRemove:
    case flutter::PointerData::Change::kHover:
    case flutter::PointerData::Change::kUp:
      return 0;
  }
  return 0;
}

FlutterEngineResult FlutterEngineSendPointerEvent(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    const FlutterPointerEvent* pointers,
    size_t events_count) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  if (pointers == nullptr || events_count == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid pointer events."");
  }

  auto packet = std::make_unique<flutter::PointerDataPacket>(events_count);

  const FlutterPointerEvent* current = pointers;

  for (size_t i = 0; i < events_count; ++i) {
    flutter::PointerData pointer_data;
    pointer_data.Clear();
    // this is currely in use only on android embedding.
    pointer_data.embedder_id = 0;
    pointer_data.time_stamp = SAFE_ACCESS(current, timestamp, 0);
    pointer_data.change = ToPointerDataChange(
        SAFE_ACCESS(current, phase, FlutterPointerPhase::kCancel));
    pointer_data.physical_x = SAFE_ACCESS(current, x, 0.0);
    pointer_data.physical_y = SAFE_ACCESS(current, y, 0.0);
    // Delta will be generated in pointer_data_packet_converter.cc.
    pointer_data.physical_delta_x = 0.0;
    pointer_data.physical_delta_y = 0.0;
    pointer_data.device = SAFE_ACCESS(current, device, 0);
    // Pointer identifier will be generated in
    // pointer_data_packet_converter.cc.
    pointer_data.pointer_identifier = 0;
    pointer_data.signal_kind = ToPointerDataSignalKind(
        SAFE_ACCESS(current, signal_kind, kFlutterPointerSignalKindNone));
    pointer_data.scroll_delta_x = SAFE_ACCESS(current, scroll_delta_x, 0.0);
    pointer_data.scroll_delta_y = SAFE_ACCESS(current, scroll_delta_y, 0.0);
    FlutterPointerDeviceKind device_kind = SAFE_ACCESS(current, device_kind, 0);
    // For backwards compatibility with embedders written before the device
    // kind and buttons were exposed, if the device kind is not set treat it
    // as a mouse, with a synthesized primary button state based on the phase.
    if (device_kind == 0) {
      pointer_data.kind = flutter::PointerData::DeviceKind::kMouse;
      pointer_data.buttons =
          PointerDataButtonsForLegacyEvent(pointer_data.change);

    } else {
      pointer_data.kind = ToPointerDataKind(device_kind);
      if (pointer_data.kind == flutter::PointerData::DeviceKind::kTouch) {
        // For touch events, set the button internally rather than requiring
        // it at the API level, since it's a confusing construction to expose.
        if (pointer_data.change == flutter::PointerData::Change::kDown ||
            pointer_data.change == flutter::PointerData::Change::kMove) {
          pointer_data.buttons = flutter::kPointerButtonTouchContact;
        }
      } else {
        // Buttons use the same mask values, so pass them through directly.
        pointer_data.buttons = SAFE_ACCESS(current, buttons, 0);
      }
    }
    packet->SetPointerData(i, pointer_data);
    current = reinterpret_cast<const FlutterPointerEvent*>(
        reinterpret_cast<const uint8_t*>(current) + current->struct_size);
  }

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->DispatchPointerDataPacket(std::move(packet))
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  ""Could not dispatch pointer events to the ""
                                  ""running Flutter application."");
}

FlutterEngineResult FlutterEngineSendPlatformMessage(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    const FlutterPlatformMessage* flutter_message) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (flutter_message == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid message argument."");
  }

  if (SAFE_ACCESS(flutter_message, channel, nullptr) == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments, ""Message argument did not specify a valid channel."");
  }

  size_t message_size = SAFE_ACCESS(flutter_message, message_size, 0);
  const uint8_t* message_data = SAFE_ACCESS(flutter_message, message, nullptr);

  if (message_size != 0 && message_data == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""Message size was non-zero but the message data was nullptr."");
  }

  const FlutterPlatformMessageResponseHandle* response_handle =
      SAFE_ACCESS(flutter_message, response_handle, nullptr);

  fml::RefPtr<flutter::PlatformMessageResponse> response;
  if (response_handle && response_handle->message) {
    response = response_handle->message->response();
  }

  fml::RefPtr<flutter::PlatformMessage> message;
  if (message_size == 0) {
    message = fml::MakeRefCounted<flutter::PlatformMessage>(
        flutter_message->channel, response);
  } else {
    message = fml::MakeRefCounted<flutter::PlatformMessage>(
        flutter_message->channel,
        std::vector<uint8_t>(message_data, message_data + message_size),
        response);
  }

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->SendPlatformMessage(std::move(message))
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  ""Could not send a message to the running ""
                                  ""Flutter application."");
}

FlutterEngineResult FlutterPlatformMessageCreateResponseHandle(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    FlutterDataCallback data_callback,
    void* user_data,
    FlutterPlatformMessageResponseHandle** response_out) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  if (data_callback == nullptr || response_out == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments, ""Data callback or the response handle was invalid."");
  }

  flutter::EmbedderPlatformMessageResponse::Callback response_callback =
      [user_data, data_callback](const uint8_t* data, size_t size) {
        data_callback(data, size, user_data);
      };

  auto platform_task_runner = reinterpret_cast<flutter::EmbedderEngine*>(engine)
                                  ->GetTaskRunners()
                                  .GetPlatformTaskRunner();

  auto handle = new FlutterPlatformMessageResponseHandle();

  handle->message = fml::MakeRefCounted<flutter::PlatformMessage>(
      """",  // The channel is empty and unused as the response handle is going
           // to referenced directly in the |FlutterEngineSendPlatformMessage|
           // with the container message discarded.
      fml::MakeRefCounted<flutter::EmbedderPlatformMessageResponse>(
          std::move(platform_task_runner), response_callback));
  *response_out = handle;
  return kSuccess;
}

FlutterEngineResult FlutterPlatformMessageReleaseResponseHandle(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    FlutterPlatformMessageResponseHandle* response) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (response == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid response handle."");
  }
  delete response;
  return kSuccess;
}

FlutterEngineResult FlutterEngineSendPlatformMessageResponse(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    const FlutterPlatformMessageResponseHandle* handle,
    const uint8_t* data,
    size_t data_length) {
  if (data_length != 0 && data == nullptr) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""Data size was non zero but the pointer to the data was null."");
  }

  auto response = handle->message->response();

  if (response) {
    if (data_length == 0) {
      response->CompleteEmpty();
    } else {
      response->Complete(std::make_unique<fml::DataMapping>(
          std::vector<uint8_t>({data, data + data_length})));
    }
  }

  delete handle;

  return kSuccess;
}

FlutterEngineResult __FlutterEngineFlushPendingTasksNow() {
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  return kSuccess;
}

FlutterEngineResult FlutterEngineRegisterExternalTexture(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    int64_t texture_identifier) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  if (texture_identifier == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Texture identifier was invalid."");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->RegisterTexture(
          texture_identifier)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not register the specified texture."");
  }
  return kSuccess;
}

FlutterEngineResult FlutterEngineUnregisterExternalTexture(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    int64_t texture_identifier) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine handle was invalid."");
  }

  if (texture_identifier == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Texture identifier was invalid."");
  }

  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->UnregisterTexture(
          texture_identifier)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not un-register the specified texture."");
  }

  return kSuccess;
}

FlutterEngineResult FlutterEngineMarkExternalTextureFrameAvailable(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    int64_t texture_identifier) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }
  if (texture_identifier == 0) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid texture identifier."");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->MarkTextureFrameAvailable(texture_identifier)) {
    return LOG_EMBEDDER_ERROR(
        kInternalInconsistency,
        ""Could not mark the texture frame as being available."");
  }
  return kSuccess;
}

FlutterEngineResult FlutterEngineUpdateSemanticsEnabled(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    bool enabled) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->SetSemanticsEnabled(
          enabled)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not update semantics state."");
  }
  return kSuccess;
}

FlutterEngineResult FlutterEngineUpdateAccessibilityFeatures(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    FlutterAccessibilityFeature flags) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->SetAccessibilityFeatures(flags)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not update accessibility features."");
  }
  return kSuccess;
}

FlutterEngineResult FlutterEngineDispatchSemanticsAction(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    uint64_t id,
    FlutterSemanticsAction action,
    const uint8_t* data,
    size_t data_length) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }
  auto engine_action = static_cast<flutter::SemanticsAction>(action);
  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->DispatchSemanticsAction(
               id, engine_action,
               std::vector<uint8_t>({data, data + data_length}))) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not dispatch semantics action."");
  }
  return kSuccess;
}

FlutterEngineResult FlutterEngineOnVsync(FLUTTER_API_SYMBOL(FlutterEngine)
                                             engine,
                                         intptr_t baton,
                                         uint64_t frame_start_time_nanos,
                                         uint64_t frame_target_time_nanos) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  TRACE_EVENT0(""flutter"", ""FlutterEngineOnVsync"");

  auto start_time = fml::TimePoint::FromEpochDelta(
      fml::TimeDelta::FromNanoseconds(frame_start_time_nanos));

  auto target_time = fml::TimePoint::FromEpochDelta(
      fml::TimeDelta::FromNanoseconds(frame_target_time_nanos));

  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->OnVsyncEvent(
          baton, start_time, target_time)) {
    return LOG_EMBEDDER_ERROR(
        kInternalInconsistency,
        ""Could not notify the running engine instance of a Vsync event."");
  }

  return kSuccess;
}

FlutterEngineResult FlutterEngineReloadSystemFonts(
    FLUTTER_API_SYMBOL(FlutterEngine) engine) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  TRACE_EVENT0(""flutter"", ""FlutterEngineReloadSystemFonts"");

  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)
           ->ReloadSystemFonts()) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not reload system fonts."");
  }

  return kSuccess;
}

void FlutterEngineTraceEventDurationBegin(const char* name) {
  fml::tracing::TraceEvent0(""flutter"", name);
}

void FlutterEngineTraceEventDurationEnd(const char* name) {
  fml::tracing::TraceEventEnd(name);
}

void FlutterEngineTraceEventInstant(const char* name) {
  fml::tracing::TraceEventInstant0(""flutter"", name);
}

FlutterEngineResult FlutterEnginePostRenderThreadTask(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    VoidCallback callback,
    void* baton) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (callback == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Render thread callback was null."");
  }

  auto task = [callback, baton]() { callback(baton); };

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->PostRenderThreadTask(task)
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  ""Could not post the render thread task."");
}

uint64_t FlutterEngineGetCurrentTime() {
  return fml::TimePoint::Now().ToEpochDelta().ToNanoseconds();
}

FlutterEngineResult FlutterEngineRunTask(FLUTTER_API_SYMBOL(FlutterEngine)
                                             engine,
                                         const FlutterTask* task) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)->RunTask(task)
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  ""Could not run the specified task."");
}

static bool DispatchJSONPlatformMessage(FLUTTER_API_SYMBOL(FlutterEngine)
                                            engine,
                                        rapidjson::Document document,
                                        const std::string& channel_name) {
  if (channel_name.size() == 0) {
    return false;
  }

  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

  if (!document.Accept(writer)) {
    return false;
  }

  const char* message = buffer.GetString();

  if (message == nullptr || buffer.GetSize() == 0) {
    return false;
  }

  auto platform_message = fml::MakeRefCounted<flutter::PlatformMessage>(
      channel_name.c_str(),                                       // channel
      std::vector<uint8_t>{message, message + buffer.GetSize()},  // message
      nullptr                                                     // response
  );

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
      ->SendPlatformMessage(std::move(platform_message));
}

FlutterEngineResult FlutterEngineUpdateLocales(FLUTTER_API_SYMBOL(FlutterEngine)
                                                   engine,
                                               const FlutterLocale** locales,
                                               size_t locales_count) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (locales_count == 0) {
    return kSuccess;
  }

  if (locales == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""No locales were specified."");
  }

  rapidjson::Document document;
  auto& allocator = document.GetAllocator();

  document.SetObject();
  document.AddMember(""method"", ""setLocale"", allocator);

  rapidjson::Value args(rapidjson::kArrayType);
  args.Reserve(locales_count * 4, allocator);
  for (size_t i = 0; i < locales_count; ++i) {
    const FlutterLocale* locale = locales[i];
    const char* language_code_str = SAFE_ACCESS(locale, language_code, nullptr);
    if (language_code_str == nullptr || ::strlen(language_code_str) == 0) {
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          ""Language code is required but not present in FlutterLocale."");
    }

    const char* country_code_str = SAFE_ACCESS(locale, country_code, """");
    const char* script_code_str = SAFE_ACCESS(locale, script_code, """");
    const char* variant_code_str = SAFE_ACCESS(locale, variant_code, """");

    rapidjson::Value language_code, country_code, script_code, variant_code;

    language_code.SetString(language_code_str, allocator);
    country_code.SetString(country_code_str ? country_code_str : """", allocator);
    script_code.SetString(script_code_str ? script_code_str : """", allocator);
    variant_code.SetString(variant_code_str ? variant_code_str : """", allocator);

    // Required.
    args.PushBack(language_code, allocator);
    args.PushBack(country_code, allocator);
    args.PushBack(script_code, allocator);
    args.PushBack(variant_code, allocator);
  }
  document.AddMember(""args"", args, allocator);

  return DispatchJSONPlatformMessage(engine, std::move(document),
                                     ""flutter/localization"")
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInternalInconsistency,
                                  ""Could not send message to update locale of ""
                                  ""a running Flutter application."");
}

bool FlutterEngineRunsAOTCompiledDartCode(void) {
  return flutter::DartVM::IsRunningPrecompiledCode();
}

FlutterEngineResult FlutterEnginePostDartObject(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    FlutterEngineDartPort port,
    const FlutterEngineDartObject* object) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (!reinterpret_cast<flutter::EmbedderEngine*>(engine)->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine not running."");
  }

  if (port == ILLEGAL_PORT) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Attempted to post to an illegal port."");
  }

  if (object == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Invalid Dart object to post."");
  }

  Dart_CObject dart_object = {};
  fml::ScopedCleanupClosure typed_data_finalizer;

  switch (object->type) {
    case kFlutterEngineDartObjectTypeNull:
      dart_object.type = Dart_CObject_kNull;
      break;
    case kFlutterEngineDartObjectTypeBool:
      dart_object.type = Dart_CObject_kBool;
      dart_object.value.as_bool = object->bool_value;
      break;
    case kFlutterEngineDartObjectTypeInt32:
      dart_object.type = Dart_CObject_kInt32;
      dart_object.value.as_int32 = object->int32_value;
      break;
    case kFlutterEngineDartObjectTypeInt64:
      dart_object.type = Dart_CObject_kInt64;
      dart_object.value.as_int64 = object->int64_value;
      break;
    case kFlutterEngineDartObjectTypeDouble:
      dart_object.type = Dart_CObject_kDouble;
      dart_object.value.as_double = object->double_value;
      break;
    case kFlutterEngineDartObjectTypeString:
      if (object->string_value == nullptr) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  ""kFlutterEngineDartObjectTypeString must be ""
                                  ""a null terminated string but was null."");
      }
      dart_object.type = Dart_CObject_kString;
      dart_object.value.as_string = const_cast<char*>(object->string_value);
      break;
    case kFlutterEngineDartObjectTypeBuffer: {
      auto* buffer = SAFE_ACCESS(object->buffer_value, buffer, nullptr);
      if (buffer == nullptr) {
        return LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  ""kFlutterEngineDartObjectTypeBuffer must ""
                                  ""specify a buffer but found nullptr."");
      }
      auto buffer_size = SAFE_ACCESS(object->buffer_value, buffer_size, 0);
      auto callback =
          SAFE_ACCESS(object->buffer_value, buffer_collect_callback, nullptr);
      auto user_data = SAFE_ACCESS(object->buffer_value, user_data, nullptr);

      // The user has provided a callback, let them manage the lifecycle of
      // the underlying data. If not, copy it out from the provided buffer.

      if (callback == nullptr) {
        dart_object.type = Dart_CObject_kTypedData;
        dart_object.value.as_typed_data.type = Dart_TypedData_kUint8;
        dart_object.value.as_typed_data.length = buffer_size;
        dart_object.value.as_typed_data.values = buffer;
      } else {
        struct ExternalTypedDataPeer {
          void* user_data = nullptr;
          VoidCallback trampoline = nullptr;
        };
        auto peer = new ExternalTypedDataPeer();
        peer->user_data = user_data;
        peer->trampoline = callback;
        // This finalizer is set so that in case of failure of the
        // Dart_PostCObject below, we collect the peer. The embedder is still
        // responsible for collecting the buffer in case of non-kSuccess
        // returns from this method. This finalizer must be released in case
        // of kSuccess returns from this method.
        typed_data_finalizer.SetClosure([peer]() {
          // This is the tiny object we use as the peer to the Dart call so
          // that we can attach the a trampoline to the embedder supplied
          // callback. In case of error, we need to collect this object lest
          // we introduce a tiny leak.
          delete peer;
        });
        dart_object.type = Dart_CObject_kExternalTypedData;
        dart_object.value.as_external_typed_data.type = Dart_TypedData_kUint8;
        dart_object.value.as_external_typed_data.length = buffer_size;
        dart_object.value.as_external_typed_data.data = buffer;
        dart_object.value.as_external_typed_data.peer = peer;
        dart_object.value.as_external_typed_data.callback =
            +[](void* unused_isolate_callback_data,
                Dart_WeakPersistentHandle unused_handle, void* peer) {
              auto typed_peer = reinterpret_cast<ExternalTypedDataPeer*>(peer);
              typed_peer->trampoline(typed_peer->user_data);
              delete typed_peer;
            };
      }
    } break;
    default:
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          ""Invalid FlutterEngineDartObjectType type specified."");
  }

  if (!Dart_PostCObject(port, &dart_object)) {
    return LOG_EMBEDDER_ERROR(kInternalInconsistency,
                              ""Could not post the object to the Dart VM."");
  }

  // On a successful call, the VM takes ownership of and is responsible for
  // invoking the finalizer.
  typed_data_finalizer.Release();
  return kSuccess;
}

FlutterEngineResult FlutterEngineNotifyLowMemoryWarning(
    FLUTTER_API_SYMBOL(FlutterEngine) raw_engine) {
  auto engine = reinterpret_cast<flutter::EmbedderEngine*>(raw_engine);
  if (engine == nullptr || !engine->IsValid()) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Engine was invalid."");
  }

  engine->GetShell().NotifyLowMemoryWarning();

  rapidjson::Document document;
  auto& allocator = document.GetAllocator();

  document.SetObject();
  document.AddMember(""type"", ""memoryPressure"", allocator);

  return DispatchJSONPlatformMessage(raw_engine, std::move(document),
                                     ""flutter/system"")
             ? kSuccess
             : LOG_EMBEDDER_ERROR(
                   kInternalInconsistency,
                   ""Could not dispatch the low memory notification message."");
}

FlutterEngineResult FlutterEnginePostCallbackOnAllNativeThreads(
    FLUTTER_API_SYMBOL(FlutterEngine) engine,
    FlutterNativeThreadCallback callback,
    void* user_data) {
  if (engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (callback == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments,
                              ""Invalid native thread callback."");
  }

  return reinterpret_cast<flutter::EmbedderEngine*>(engine)
                 ->PostTaskOnEngineManagedNativeThreads(
                     [callback, user_data](FlutterNativeThreadType type) {
                       callback(type, user_data);
                     })
             ? kSuccess
             : LOG_EMBEDDER_ERROR(kInvalidArguments,
                                  ""Internal error while attempting to post ""
                                  ""tasks to all threads."");
}

namespace {
static bool ValidDisplayConfiguration(const FlutterEngineDisplay* displays,
                                      size_t display_count) {
  std::set<FlutterEngineDisplayId> display_ids;
  for (size_t i = 0; i < display_count; i++) {
    if (displays[i].single_display && display_count != 1) {
      return false;
    }
    display_ids.insert(displays[i].display_id);
  }

  return display_ids.size() == display_count;
}
}  // namespace

FlutterEngineResult FlutterEngineNotifyDisplayUpdate(
    FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
    const FlutterEngineDisplaysUpdateType update_type,
    const FlutterEngineDisplay* embedder_displays,
    size_t display_count) {
  if (raw_engine == nullptr) {
    return LOG_EMBEDDER_ERROR(kInvalidArguments, ""Invalid engine handle."");
  }

  if (!ValidDisplayConfiguration(embedder_displays, display_count)) {
    return LOG_EMBEDDER_ERROR(
        kInvalidArguments,
        ""Invalid FlutterEngineDisplay configuration specified."");
  }

  auto engine = reinterpret_cast<flutter::EmbedderEngine*>(raw_engine);

  switch (update_type) {
    case kFlutterEngineDisplaysUpdateTypeStartup: {
      std::vector<flutter::Display> displays;
      for (size_t i = 0; i < display_count; i++) {
        flutter::Display display =
            flutter::Display(embedder_displays[i].refresh_rate);
        if (!embedder_displays[i].single_display) {
          display = flutter::Display(embedder_displays[i].display_id,
                                     embedder_displays[i].refresh_rate);
        }
        displays.push_back(display);
      }
      engine->GetShell().OnDisplayUpdates(flutter::DisplayUpdateType::kStartup,
                                          displays);
      return kSuccess;
    }
    default:
      return LOG_EMBEDDER_ERROR(
          kInvalidArguments,
          ""Invalid FlutterEngineDisplaysUpdateType type specified."");
  }
}
",16322,True,2926.771186036857,median
"// Copyright (c) 2009-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>
#include <core_io.h>
#include <interfaces/chain.h>
#include <key_io.h>
#include <merkleblock.h>
#include <rpc/server.h>
#include <rpc/util.h>
#include <script/descriptor.h>
#include <script/script.h>
#include <script/standard.h>
#include <sync.h>
#include <util/bip32.h>
#include <util/system.h>
#include <util/time.h>
#include <util/translation.h>
#include <wallet/rpcwallet.h>
#include <wallet/wallet.h>

#include <stdint.h>
#include <tuple>

#include <boost/algorithm/string.hpp>

#include <univalue.h>



std::string static EncodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (const unsigned char c : str) {
        if (c <= 32 || c >= 128 || c == '%') {
            ret << '%' << HexStr(&c, &c + 1);
        } else {
            ret << c;
        }
    }
    return ret.str();
}

static std::string DecodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (unsigned int pos = 0; pos < str.length(); pos++) {
        unsigned char c = str[pos];
        if (c == '%' && pos+2 < str.length()) {
            c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
                ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
            pos += 2;
        }
        ret << c;
    }
    return ret.str();
}

static bool GetWalletAddressesForKey(LegacyScriptPubKeyMan* spk_man, const CWallet* const pwallet, const CKeyID& keyid, std::string& strAddr, std::string& strLabel) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    bool fLabelFound = false;
    CKey key;
    spk_man->GetKey(keyid, key);
    for (const auto& dest : GetAllDestinationsForKey(key.GetPubKey())) {
        const auto* address_book_entry = pwallet->FindAddressBookEntry(dest);
        if (address_book_entry) {
            if (!strAddr.empty()) {
                strAddr += "","";
            }
            strAddr += EncodeDestination(dest);
            strLabel = EncodeDumpString(address_book_entry->GetLabel());
            fLabelFound = true;
        }
    }
    if (!fLabelFound) {
        strAddr = EncodeDestination(GetDestinationForKey(key.GetPubKey(), pwallet->m_default_address_type));
    }
    return fLabelFound;
}

static const int64_t TIMESTAMP_MIN = 0;

static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver, int64_t time_begin = TIMESTAMP_MIN, bool update = true)
{
    int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
    if (wallet.IsAbortingRescan()) {
        throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
    } else if (scanned_time > time_begin) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan was unable to fully rescan the blockchain. Some transactions may be missing."");
    }
}

UniValue importprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprivkey"",
                ""\\nAdds a private key (as returned by dumpprivkey) to your wallet. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one private key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""yupostprivkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The private key (see dumpprivkey)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""current label if address exists, otherwise \\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nDump a private key\\n""
            + HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""") +
            ""\\nImport the private key with rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nImport using a label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""testing\\"" false"") +
            ""\\nImport using default blank label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importprivkey"", ""\\""mykey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
    }

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    WalletRescanReserver reserver(pwallet);
    bool fRescan = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        std::string strSecret = request.params[0].get_str();
        std::string strLabel = """";
        if (!request.params[1].isNull())
            strLabel = request.params[1].get_str();

        // Whether to perform rescan after import
        if (!request.params[2].isNull())
            fRescan = request.params[2].get_bool();

        if (fRescan && pwallet->chain().havePruned()) {
            // Exit early and print an error.
            // If a block is pruned after this check, we will import the key(s),
            // but fail the rescan with a generic error.
            throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
        }

        if (fRescan && !reserver.reserve()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
        }

        CKey key = DecodeSecret(strSecret);
        if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        if (pwallet->m_wallet_unlock_staking_only)
            throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, ""Wallet is unlocked for staking only."");

        CPubKey pubkey = key.GetPubKey();
        CHECK_NONFATAL(key.VerifyPubKey(pubkey));
        CKeyID vchAddress = pubkey.GetID();
        {
            pwallet->MarkDirty();

            // We don't know which corresponding address will be used;
            // label all new addresses, and label existing addresses if a
            // label was passed.
            for (const auto& dest : GetAllDestinationsForKey(pubkey)) {
                if (!request.params[1].isNull() || !pwallet->FindAddressBookEntry(dest)) {
                    pwallet->SetAddressBook(dest, strLabel, ""receive"");
                }
            }

            // Use timestamp of 1 to scan the whole chain
            if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
            }

            // Add the wpkh script for this key if possible
            if (pubkey.IsCompressed()) {
                pwallet->ImportScripts({GetScriptForDestination(WitnessV0KeyHash(vchAddress))}, 0 /* timestamp */);
            }
        }
    }
    if (fRescan) {
        RescanWallet(*pwallet, reserver);
    }

    return NullUniValue;
}

UniValue abortrescan(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""abortrescan"",
                ""\\nStops current wallet rescan triggered by an RPC call, e.g. by an importprivkey call.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {},
                RPCResult{RPCResult::Type::BOOL, """", ""Whether the abort was successful""},
                RPCExamples{
            ""\\nImport a private key\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nAbort the running wallet rescan\\n""
            + HelpExampleCli(""abortrescan"", """") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""abortrescan"", """")
                },
            }.Check(request);

    if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
    pwallet->AbortRescan();
    return true;
}

UniValue importaddress(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importaddress"",
                ""\\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""If you have the full public key, you should call importpubkey instead of this.\\n""
            ""Hint: use importmulti to import more than one address.\\n""
            ""\\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\\n""
            ""as change, and not show up in many RPCs.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The YuPost address (or hex-encoded script)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                    {""p2sh"", RPCArg::Type::BOOL, /* default */ ""false"", ""Add the P2SH version of the script as well""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nImport an address with rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importaddress"", ""\\""myaddress\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*pwallet, true);

    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    // Whether to import a p2sh version, too
    bool fP2SH = false;
    if (!request.params[3].isNull())
        fP2SH = request.params[3].get_bool();

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        CTxDestination dest = DecodeDestination(request.params[0].get_str());
        if (IsValidDestination(dest)) {
            if (fP2SH) {
                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Cannot use the p2sh flag with an address - use a script instead"");
            }

            pwallet->MarkDirty();

            pwallet->ImportScriptPubKeys(strLabel, {GetScriptForDestination(dest)}, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else if (IsHex(request.params[0].get_str())) {
            std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
            CScript redeem_script(data.begin(), data.end());

            std::set<CScript> scripts = {redeem_script};
            pwallet->ImportScripts(scripts, 0 /* timestamp */);

            if (fP2SH) {
                scripts.insert(GetScriptForDestination(ScriptHash(CScriptID(redeem_script))));
            }

            pwallet->ImportScriptPubKeys(strLabel, scripts, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid YuPost address or script"");
        }
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions();
        }
    }

    return NullUniValue;
}

UniValue importprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprunedfunds"",
                ""\\nImports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\\n"",
                {
                    {""rawtransaction"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""A raw transaction in hex funding an already-existing address in wallet""},
                    {""txoutproof"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex output from gettxoutproof that contains the transaction""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{""""},
            }.Check(request);

    CMutableTransaction tx;
    if (!DecodeHexTx(tx, request.params[0].get_str()))
        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, ""TX decode failed"");
    uint256 hashTx = tx.GetHash();
    CWalletTx wtx(pwallet, MakeTransactionRef(std::move(tx)));

    CDataStream ssMB(ParseHexV(request.params[1], ""proof""), SER_NETWORK, PROTOCOL_VERSION);
    CMerkleBlock merkleBlock;
    ssMB >> merkleBlock;

    //Search partial merkle tree in proof for our transaction and index in valid block
    std::vector<uint256> vMatch;
    std::vector<unsigned int> vIndex;
    if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) != merkleBlock.header.hashMerkleRoot) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Something wrong with merkleblock"");
    }

    auto locked_chain = pwallet->chain().lock();
    Optional<int> height = locked_chain->getBlockHeight(merkleBlock.header.GetHash());
    if (height == nullopt) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found in chain"");
    }

    std::vector<uint256>::const_iterator it;
    if ((it = std::find(vMatch.begin(), vMatch.end(), hashTx)) == vMatch.end()) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction given doesn't exist in proof"");
    }

    unsigned int txnIndex = vIndex[it - vMatch.begin()];

    CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED, *height, merkleBlock.header.GetHash(), txnIndex);
    wtx.m_confirm = confirm;

    LOCK(pwallet->cs_wallet);

    if (pwallet->IsMine(*wtx.tx)) {
        pwallet->AddToWallet(wtx, false);
        return NullUniValue;
    }

    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""No addresses in wallet correspond to included transaction"");
}

UniValue removeprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""removeprunedfunds"",
                ""\\nDeletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\\n"",
                {
                    {""txid"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex-encoded id of the transaction you are deleting""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
                    HelpExampleCli(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    uint256 hash(ParseHashV(request.params[0], ""txid""));
    std::vector<uint256> vHash;
    vHash.push_back(hash);
    std::vector<uint256> vHashOut;

    if (pwallet->ZapSelectTx(vHash, vHashOut) != DBErrors::LOAD_OK) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Could not properly delete the transaction."");
    }

    if(vHashOut.empty()) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Transaction does not exist in wallet."");
    }

    return NullUniValue;
}

UniValue importpubkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importpubkey"",
                ""\\nAdds a public key (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one public key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported pubkey exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""pubkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The hex-encoded public key""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nImport a public key with rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importpubkey"", ""\\""mypubkey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    if (!IsHex(request.params[0].get_str()))
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey must be a hex string"");
    std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
    CPubKey pubKey(data.begin(), data.end());
    if (!pubKey.IsFullyValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey is not a valid public key"");

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        std::set<CScript> script_pub_keys;
        for (const auto& dest : GetAllDestinationsForKey(pubKey)) {
            script_pub_keys.insert(GetScriptForDestination(dest));
        }

        pwallet->MarkDirty();

        pwallet->ImportScriptPubKeys(strLabel, script_pub_keys, true /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);

        pwallet->ImportPubKeys({pubKey.GetID()}, {{pubKey.GetID(), pubKey}} , {} /* key_origins */, false /* add_keypool */, false /* internal */, 1 /* timestamp */);
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions();
        }
    }

    return NullUniValue;
}


UniValue importwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importwallet"",
                ""\\nImports keys from a wallet dump file (see dumpwallet). Requires a new wallet backup to include imported keys.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The wallet file""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nDump the wallet\\n""
            + HelpExampleCli(""dumpwallet"", ""\\""test\\"""") +
            ""\\nImport the wallet\\n""
            + HelpExampleCli(""importwallet"", ""\\""test\\"""") +
            ""\\nImport using the json rpc call\\n""
            + HelpExampleRpc(""importwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    if (pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (!reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t nTimeBegin = 0;
    bool fGood = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        fsbridge::ifstream file;
        file.open(request.params[0].get_str(), std::ios::in | std::ios::ate);
        if (!file.is_open()) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");
        }
        Optional<int> tip_height = locked_chain->getHeight();
        nTimeBegin = tip_height ? locked_chain->getBlockTime(*tip_height) : 0;

        int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
        file.seekg(0, file.beg);

        // Use uiInterface.ShowProgress instead of pwallet.ShowProgress because pwallet.ShowProgress has a cancel button tied to AbortRescan which
        // we don't want for this progress bar showing the import progress. uiInterface.ShowProgress does not have a cancel button.
        pwallet->chain().showProgress(strprintf(""%s "" + _(""Importing..."").translated, pwallet->GetDisplayName()), 0, false); // show progress dialog in GUI
        std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
        std::vector<std::pair<CScript, int64_t>> scripts;
        while (file.good()) {
            pwallet->chain().showProgress("""", std::max(1, std::min(50, (int)(((double)file.tellg() / (double)nFilesize) * 100))), false);
            std::string line;
            std::getline(file, line);
            if (line.empty() || line[0] == '#')
                continue;

            std::vector<std::string> vstr;
            boost::split(vstr, line, boost::is_any_of("" ""));
            if (vstr.size() < 2)
                continue;
            CKey key = DecodeSecret(vstr[0]);
            if (key.IsValid()) {
                int64_t nTime = ParseISO8601DateTime(vstr[1]);
                std::string strLabel;
                bool fLabel = true;
                for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
                    if (vstr[nStr].front() == '#')
                        break;
                    if (vstr[nStr] == ""change=1"")
                        fLabel = false;
                    if (vstr[nStr] == ""reserve=1"")
                        fLabel = false;
                    if (vstr[nStr].substr(0,6) == ""label="") {
                        strLabel = DecodeDumpString(vstr[nStr].substr(6));
                        fLabel = true;
                    }
                }
                keys.push_back(std::make_tuple(key, nTime, fLabel, strLabel));
            } else if(IsHex(vstr[0])) {
                std::vector<unsigned char> vData(ParseHex(vstr[0]));
                CScript script = CScript(vData.begin(), vData.end());
                int64_t birth_time = ParseISO8601DateTime(vstr[1]);
                scripts.push_back(std::pair<CScript, int64_t>(script, birth_time));
            }
        }
        file.close();
        // We now know whether we are importing private keys, so we can error if private keys are disabled
        if (keys.size() > 0 && pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
            throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when private keys are disabled"");
        }
        double total = (double)(keys.size() + scripts.size());
        double progress = 0;
        for (const auto& key_tuple : keys) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CKey& key = std::get<0>(key_tuple);
            int64_t time = std::get<1>(key_tuple);
            bool has_label = std::get<2>(key_tuple);
            std::string label = std::get<3>(key_tuple);

            CPubKey pubkey = key.GetPubKey();
            CHECK_NONFATAL(key.VerifyPubKey(pubkey));
            CKeyID keyid = pubkey.GetID();

            pwallet->WalletLogPrintf(""Importing %s...\\n"", EncodeDestination(PKHash(keyid)));

            if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
                pwallet->WalletLogPrintf(""Error importing key for %s\\n"", EncodeDestination(PKHash(keyid)));
                fGood = false;
                continue;
            }

            if (has_label)
                pwallet->SetAddressBook(PKHash(keyid), label, ""receive"");

            nTimeBegin = std::min(nTimeBegin, time);
            progress++;
        }
        for (const auto& script_pair : scripts) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CScript& script = script_pair.first;
            int64_t time = script_pair.second;

            if (!pwallet->ImportScripts({script}, time)) {
                pwallet->WalletLogPrintf(""Error importing script %s\\n"", HexStr(script));
                fGood = false;
                continue;
            }
            if (time > 0) {
                nTimeBegin = std::min(nTimeBegin, time);
            }

            progress++;
        }
        pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    }
    pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
    pwallet->MarkDirty();

    if (!fGood)
        throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding some keys/scripts to wallet"");

    return NullUniValue;
}

UniValue dumpprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    const CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpprivkey"",
                ""\\nReveals the private key corresponding to 'address'.\\n""
                ""Then the importprivkey can be used with this output\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The yupost address for the private key""},
                },
                RPCResult{
                    RPCResult::Type::STR, ""key"", ""The private key""
                },
                RPCExamples{
                    HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""")
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""")
            + HelpExampleRpc(""dumpprivkey"", ""\\""myaddress\\"""")
                },
            }.Check(request);

    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*wallet);

    auto locked_chain = pwallet->chain().lock();
    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);

    EnsureWalletIsUnlocked(pwallet);

    std::string strAddress = request.params[0].get_str();
    CTxDestination dest = DecodeDestination(strAddress);
    if (!IsValidDestination(dest)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid YuPost address"");
        if (pwallet->m_wallet_unlock_staking_only)
            throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, ""Wallet is unlocked for staking only."");
    }
    auto keyid = GetKeyForDestination(spk_man, dest);
    if (keyid.IsNull()) {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Address does not refer to a key"");
    }
    CKey vchSecret;
    if (!spk_man.GetKey(keyid, vchSecret)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Private key for address "" + strAddress + "" is not known"");
    }
    return EncodeSecret(vchSecret);
}


UniValue dumpwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    const CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpwallet"",
                ""\\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The filename with path (either absolute or relative to yupostd)""},
                },
                RPCResult{
                    RPCResult::Type::OBJ, """", """",
                    {
                        {RPCResult::Type::STR, ""filename"", ""The filename with full absolute path""},
                    }
                },
                RPCExamples{
                    HelpExampleCli(""dumpwallet"", ""\\""test\\"""")
            + HelpExampleRpc(""dumpwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*wallet);

    auto locked_chain = pwallet->chain().lock();
    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);

    EnsureWalletIsUnlocked(pwallet);

    fs::path filepath = request.params[0].get_str();
    filepath = fs::absolute(filepath);

    /* Prevent arbitrary files from being overwritten. There have been reports
     * that users have overwritten wallet files this way:
     * https://github.com/bitcoin/bitcoin/issues/9934
     * It may also avoid other security issues.
     */
    if (fs::exists(filepath)) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, filepath.string() + "" already exists. If you are sure this is what you want, move it out of the way first"");
    }

    fsbridge::ofstream file;
    file.open(filepath);
    if (!file.is_open())
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");

    std::map<CKeyID, int64_t> mapKeyBirth;
    const std::map<CKeyID, int64_t>& mapKeyPool = spk_man.GetAllReserveKeys();
    pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);

    std::set<CScriptID> scripts = spk_man.GetCScripts();

    // sort time/key pairs
    std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
    for (const auto& entry : mapKeyBirth) {
        vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
    }
    mapKeyBirth.clear();
    std::sort(vKeyBirth.begin(), vKeyBirth.end());

    // produce output
    file << strprintf(""# Wallet dump created by YuPost %s\\n"", CLIENT_BUILD);
    file << strprintf(""# * Created on %s\\n"", FormatISO8601DateTime(GetTime()));
    const Optional<int> tip_height = locked_chain->getHeight();
    file << strprintf(""# * Best block at time of backup was %i (%s),\\n"", tip_height.get_value_or(-1), tip_height ? locked_chain->getBlockHash(*tip_height).ToString() : ""(missing block hash)"");
    file << strprintf(""#   mined on %s\\n"", tip_height ? FormatISO8601DateTime(locked_chain->getBlockTime(*tip_height)) : ""(missing block time)"");
    file << ""\\n"";

    // add the base58check encoded extended master if the wallet uses HD
    CKeyID seed_id = spk_man.GetHDChain().seed_id;
    if (!seed_id.IsNull())
    {
        CKey seed;
        if (spk_man.GetKey(seed_id, seed)) {
            CExtKey masterKey;
            masterKey.SetSeed(seed.begin(), seed.size());

            file << ""# extended private masterkey: "" << EncodeExtKey(masterKey) << ""\\n\\n"";
        }
    }
    for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
        const CKeyID &keyid = it->second;
        std::string strTime = FormatISO8601DateTime(it->first);
        std::string strAddr;
        std::string strLabel;
        CKey key;
        if (spk_man.GetKey(keyid, key)) {
            file << strprintf(""%s %s "", EncodeSecret(key), strTime);
            if (GetWalletAddressesForKey(&spk_man, pwallet, keyid, strAddr, strLabel)) {
               file << strprintf(""label=%s"", strLabel);
            } else if (keyid == seed_id) {
                file << ""hdseed=1"";
            } else if (mapKeyPool.count(keyid)) {
                file << ""reserve=1"";
            } else if (spk_man.mapKeyMetadata[keyid].hdKeypath == ""s"") {
                file << ""inactivehdseed=1"";
            } else {
                file << ""change=1"";
            }
            file << strprintf("" # addr=%s%s\\n"", strAddr, (spk_man.mapKeyMetadata[keyid].has_key_origin ? "" hdkeypath=""+WriteHDKeypath(spk_man.mapKeyMetadata[keyid].key_origin.path) : """"));
        }
    }
    file << ""\\n"";
    for (const CScriptID &scriptid : scripts) {
        CScript script;
        std::string create_time = ""0"";
        std::string address = EncodeDestination(ScriptHash(scriptid));
        // get birth times for scripts with metadata
        auto it = spk_man.m_script_metadata.find(scriptid);
        if (it != spk_man.m_script_metadata.end()) {
            create_time = FormatISO8601DateTime(it->second.nCreateTime);
        }
        if(spk_man.GetCScript(scriptid, script)) {
            file << strprintf(""%s %s script=1"", HexStr(script.begin(), script.end()), create_time);
            file << strprintf("" # addr=%s\\n"", address);
        }
    }
    file << ""\\n"";
    file << ""# End of dump\\n"";
    file.close();

    UniValue reply(UniValue::VOBJ);
    reply.pushKV(""filename"", filepath.string());

    return reply;
}

struct ImportData
{
    // Input data
    std::unique_ptr<CScript> redeemscript; //!< Provided redeemScript; will be moved to `import_scripts` if relevant.
    std::unique_ptr<CScript> witnessscript; //!< Provided witnessScript; will be moved to `import_scripts` if relevant.

    // Output data
    std::set<CScript> import_scripts;
    std::map<CKeyID, bool> used_keys; //!< Import these private keys if available (the value indicates whether if the key is required for solvability)
    std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> key_origins;
};

enum class ScriptContext
{
    TOP, //!< Top-level scriptPubKey
    P2SH, //!< P2SH redeemScript
    WITNESS_V0, //!< P2WSH witnessScript
};

// Analyse the provided scriptPubKey, determining which keys and which redeem scripts from the ImportData struct are needed to spend it, and mark them as used.
// Returns an error string, or the empty string for success.
static std::string RecurseImportData(const CScript& script, ImportData& import_data, const ScriptContext script_ctx)
{
    // Use Solver to obtain script type and parsed pubkeys or hashes:
    std::vector<std::vector<unsigned char>> solverdata;
    txnouttype script_type = Solver(script, solverdata);

    switch (script_type) {
    case TX_PUBKEY: {
        CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
        import_data.used_keys.emplace(pubkey.GetID(), false);
        return """";
    }
    case TX_PUBKEYHASH: {
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        return """";
    }
    case TX_SCRIPTHASH: {
        if (script_ctx == ScriptContext::P2SH) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside another P2SH"");
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside a P2WSH"");
        CHECK_NONFATAL(script_ctx == ScriptContext::TOP);
        CScriptID id = CScriptID(uint160(solverdata[0]));
        auto subscript = std::move(import_data.redeemscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing redeemscript"";
        if (CScriptID(*subscript) != id) return ""redeemScript does not match the scriptPubKey"";
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::P2SH);
    }
    case TX_MULTISIG: {
        for (size_t i = 1; i + 1< solverdata.size(); ++i) {
            CPubKey pubkey(solverdata[i].begin(), solverdata[i].end());
            import_data.used_keys.emplace(pubkey.GetID(), false);
        }
        return """";
    }
    case TX_WITNESS_V0_SCRIPTHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WSH inside another P2WSH"");
        uint256 fullid(solverdata[0]);
        CScriptID id;
        CRIPEMD160().Write(fullid.begin(), fullid.size()).Finalize(id.begin());
        auto subscript = std::move(import_data.witnessscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing witnessscript"";
        if (CScriptID(*subscript) != id) return ""witnessScript does not match the scriptPubKey or redeemScript"";
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WSH requires the TOP script imported (see script/ismine.cpp)
        }
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::WITNESS_V0);
    }
    case TX_WITNESS_V0_KEYHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WPKH inside P2WSH"");
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WPKH requires the TOP script imported (see script/ismine.cpp)
        }
        return """";
    }
    case TX_NULL_DATA:
        return ""unspendable script"";
    case TX_NONSTANDARD:
    case TX_WITNESS_UNKNOWN:
    default:
        return ""unrecognized script"";
    }
}

static UniValue ProcessImportLegacy(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    // First ensure scriptPubKey has either a script or JSON with ""address"" string
    const UniValue& scriptPubKey = data[""scriptPubKey""];
    bool isScript = scriptPubKey.getType() == UniValue::VSTR;
    if (!isScript && !(scriptPubKey.getType() == UniValue::VOBJ && scriptPubKey.exists(""address""))) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""scriptPubKey must be string with script or JSON with address string"");
    }
    const std::string& output = isScript ? scriptPubKey.get_str() : scriptPubKey[""address""].get_str();

    // Optional fields.
    const std::string& strRedeemScript = data.exists(""redeemscript"") ? data[""redeemscript""].get_str() : """";
    const std::string& witness_script_hex = data.exists(""witnessscript"") ? data[""witnessscript""].get_str() : """";
    const UniValue& pubKeys = data.exists(""pubkeys"") ? data[""pubkeys""].get_array() : UniValue();
    const UniValue& keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();
    const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
    const bool watchOnly = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    if (data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for a non-descriptor import"");
    }

    // Generate the script and destination for the scriptPubKey provided
    CScript script;
    if (!isScript) {
        CTxDestination dest = DecodeDestination(output);
        if (!IsValidDestination(dest)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid address \\"""" + output + ""\\"""");
        }
        script = GetScriptForDestination(dest);
    } else {
        if (!IsHex(output)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid scriptPubKey \\"""" + output + ""\\"""");
        }
        std::vector<unsigned char> vData(ParseHex(output));
        script = CScript(vData.begin(), vData.end());
        CTxDestination dest;
        if (!ExtractDestination(script, dest) && !internal) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal must be set to true for nonstandard scriptPubKey imports."");
        }
    }
    script_pub_keys.emplace(script);

    // Parse all arguments
    if (strRedeemScript.size()) {
        if (!IsHex(strRedeemScript)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid redeem script \\"""" + strRedeemScript + ""\\"": must be hex string"");
        }
        auto parsed_redeemscript = ParseHex(strRedeemScript);
        import_data.redeemscript = MakeUnique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
    }
    if (witness_script_hex.size()) {
        if (!IsHex(witness_script_hex)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid witness script \\"""" + witness_script_hex + ""\\"": must be hex string"");
        }
        auto parsed_witnessscript = ParseHex(witness_script_hex);
        import_data.witnessscript = MakeUnique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
    }
    for (size_t i = 0; i < pubKeys.size(); ++i) {
        const auto& str = pubKeys[i].get_str();
        if (!IsHex(str)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" must be a hex string"");
        }
        auto parsed_pubkey = ParseHex(str);
        CPubKey pubkey(parsed_pubkey.begin(), parsed_pubkey.end());
        if (!pubkey.IsFullyValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" is not a valid public key"");
        }
        pubkey_map.emplace(pubkey.GetID(), pubkey);
        ordered_pubkeys.push_back(pubkey.GetID());
    }
    for (size_t i = 0; i < keys.size(); ++i) {
        const auto& str = keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();
        if (pubkey_map.count(id)) {
            pubkey_map.erase(id);
        }
        privkey_map.emplace(id, key);
    }


    // Verify and process input data
    have_solving_data = import_data.redeemscript || import_data.witnessscript || pubkey_map.size() || privkey_map.size();
    if (have_solving_data) {
        // Match up data in import_data with the scriptPubKey in script.
        auto error = RecurseImportData(script, import_data, ScriptContext::TOP);

        // Verify whether the watchonly option corresponds to the availability of private keys.
        bool spendable = std::all_of(import_data.used_keys.begin(), import_data.used_keys.end(), [&](const std::pair<CKeyID, bool>& used_key){ return privkey_map.count(used_key.first) > 0; });
        if (!watchOnly && !spendable) {
            warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
        }
        if (watchOnly && spendable) {
            warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
        }

        // Check that all required keys for solvability are provided.
        if (error.empty()) {
            for (const auto& require_key : import_data.used_keys) {
                if (!require_key.second) continue; // Not a required key
                if (pubkey_map.count(require_key.first) == 0 && privkey_map.count(require_key.first) == 0) {
                    error = ""some required keys are missing"";
                }
            }
        }

        if (!error.empty()) {
            warnings.push_back(""Importing as non-solvable: "" + error + "". If this is intentional, don't provide any keys, pubkeys, witnessscript, or redeemscript."");
            import_data = ImportData();
            pubkey_map.clear();
            privkey_map.clear();
            have_solving_data = false;
        } else {
            // RecurseImportData() removes any relevant redeemscript/witnessscript from import_data, so we can use that to discover if a superfluous one was provided.
            if (import_data.redeemscript) warnings.push_back(""Ignoring redeemscript as this is not a P2SH script."");
            if (import_data.witnessscript) warnings.push_back(""Ignoring witnessscript as this is not a (P2SH-)P2WSH script."");
            for (auto it = privkey_map.begin(); it != privkey_map.end(); ) {
                auto oldit = it++;
                if (import_data.used_keys.count(oldit->first) == 0) {
                    warnings.push_back(""Ignoring irrelevant private key."");
                    privkey_map.erase(oldit);
                }
            }
            for (auto it = pubkey_map.begin(); it != pubkey_map.end(); ) {
                auto oldit = it++;
                auto key_data_it = import_data.used_keys.find(oldit->first);
                if (key_data_it == import_data.used_keys.end() || !key_data_it->second) {
                    warnings.push_back(""Ignoring public key \\"""" + HexStr(oldit->first) + ""\\"" as it doesn't appear inside P2PKH or P2WPKH."");
                    pubkey_map.erase(oldit);
                }
            }
        }
    }

    return warnings;
}

static UniValue ProcessImportDescriptor(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    const std::string& descriptor = data[""desc""].get_str();
    FlatSigningProvider keys;
    std::string error;
    auto parsed_desc = Parse(descriptor, keys, error, /* require_checksum = */ true);
    if (!parsed_desc) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
    }

    have_solving_data = parsed_desc->IsSolvable();
    const bool watch_only = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    int64_t range_start = 0, range_end = 0;
    if (!parsed_desc->IsRange() && data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for an un-ranged descriptor"");
    } else if (parsed_desc->IsRange()) {
        if (!data.exists(""range"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Descriptor is ranged, please specify the range"");
        }
        std::tie(range_start, range_end) = ParseDescriptorRange(data[""range""]);
    }

    const UniValue& priv_keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();

    // Expand all descriptors to get public keys and scripts, and private keys if available.
    for (int i = range_start; i <= range_end; ++i) {
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        parsed_desc->Expand(i, keys, scripts_temp, out_keys);
        std::copy(scripts_temp.begin(), scripts_temp.end(), std::inserter(script_pub_keys, script_pub_keys.end()));
        for (const auto& key_pair : out_keys.pubkeys) {
            ordered_pubkeys.push_back(key_pair.first);
        }

        for (const auto& x : out_keys.scripts) {
            import_data.import_scripts.emplace(x.second);
        }

        parsed_desc->ExpandPrivate(i, keys, out_keys);

        std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(), std::inserter(pubkey_map, pubkey_map.end()));
        std::copy(out_keys.keys.begin(), out_keys.keys.end(), std::inserter(privkey_map, privkey_map.end()));
        import_data.key_origins.insert(out_keys.origins.begin(), out_keys.origins.end());
    }

    for (size_t i = 0; i < priv_keys.size(); ++i) {
        const auto& str = priv_keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();

        // Check if this private key corresponds to a public key from the descriptor
        if (!pubkey_map.count(id)) {
            warnings.push_back(""Ignoring irrelevant private key."");
        } else {
            privkey_map.emplace(id, key);
        }
    }

    // Check if all the public keys have corresponding private keys in the import for spendability.
    // This does not take into account threshold multisigs which could be spendable without all keys.
    // Thus, threshold multisigs without all keys will be considered not spendable here, even if they are,
    // perhaps triggering a false warning message. This is consistent with the current wallet IsMine check.
    bool spendable = std::all_of(pubkey_map.begin(), pubkey_map.end(),
        [&](const std::pair<CKeyID, CPubKey>& used_key) {
            return privkey_map.count(used_key.first) > 0;
        }) && std::all_of(import_data.key_origins.begin(), import_data.key_origins.end(),
        [&](const std::pair<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& entry) {
            return privkey_map.count(entry.first) > 0;
        });
    if (!watch_only && !spendable) {
        warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
    }
    if (watch_only && spendable) {
        warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
    }

    return warnings;
}

static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    UniValue warnings(UniValue::VARR);
    UniValue result(UniValue::VOBJ);

    try {
        const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
        // Internal addresses should not have a label
        if (internal && data.exists(""label"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal addresses should not have a label"");
        }
        const std::string& label = data.exists(""label"") ? data[""label""].get_str() : """";
        const bool add_keypool = data.exists(""keypool"") ? data[""keypool""].get_bool() : false;

        // Add to keypool only works with privkeys disabled
        if (add_keypool && !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Keys can only be imported to the keypool when private keys are disabled"");
        }

        ImportData import_data;
        std::map<CKeyID, CPubKey> pubkey_map;
        std::map<CKeyID, CKey> privkey_map;
        std::set<CScript> script_pub_keys;
        std::vector<CKeyID> ordered_pubkeys;
        bool have_solving_data;

        if (data.exists(""scriptPubKey"") && data.exists(""desc"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Both a descriptor and a scriptPubKey should not be provided."");
        } else if (data.exists(""scriptPubKey"")) {
            warnings = ProcessImportLegacy(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else if (data.exists(""desc"")) {
            warnings = ProcessImportDescriptor(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Either a descriptor or scriptPubKey must be provided."");
        }

        // If private keys are disabled, abort if private keys are being imported
        if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !privkey_map.empty()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
        }

        // Check whether we have any work to do
        for (const CScript& script : script_pub_keys) {
            if (pwallet->IsMine(script) & ISMINE_SPENDABLE) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""The wallet already contains the private key for this address or script (\\"""" + HexStr(script.begin(), script.end()) + ""\\"")"");
            }
        }

        // All good, time to import
        pwallet->MarkDirty();
        if (!pwallet->ImportScripts(import_data.import_scripts, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding script to wallet"");
        }
        if (!pwallet->ImportPrivKeys(privkey_map, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
        }
        if (!pwallet->ImportPubKeys(ordered_pubkeys, pubkey_map, import_data.key_origins, add_keypool, internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }
        if (!pwallet->ImportScriptPubKeys(label, script_pub_keys, have_solving_data, !internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }

        result.pushKV(""success"", UniValue(true));
    } catch (const UniValue& e) {
        result.pushKV(""success"", UniValue(false));
        result.pushKV(""error"", e);
    } catch (...) {
        result.pushKV(""success"", UniValue(false));

        result.pushKV(""error"", JSONRPCError(RPC_MISC_ERROR, ""Missing required fields""));
    }
    if (warnings.size()) result.pushKV(""warnings"", warnings);
    return result;
}

static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
{
    if (data.exists(""timestamp"")) {
        const UniValue& timestamp = data[""timestamp""];
        if (timestamp.isNum()) {
            return timestamp.get_int64();
        } else if (timestamp.isStr() && timestamp.get_str() == ""now"") {
            return now;
        }
        throw JSONRPCError(RPC_TYPE_ERROR, strprintf(""Expected number or \\""now\\"" timestamp value for key. got type %s"", uvTypeName(timestamp.type())));
    }
    throw JSONRPCError(RPC_TYPE_ERROR, ""Missing required timestamp field for key"");
}

UniValue importmulti(const JSONRPCRequest& mainRequest)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importmulti"",
                ""\\nImport addresses/scripts (with private or public keys, redeem script (P2SH)), optionally rescanning the blockchain from the earliest creation time of the imported scripts. Requires a new wallet backup.\\n""
                ""If an address/script is imported without all of the private keys required to spend from that address, it will be watchonly. The 'watchonly' option must be set to true in this case or a warning will be returned.\\n""
                ""Conversely, if all the private keys are provided and the address/script is spendable, the watchonly option must be set to false, or a warning will be returned.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported keys, addresses or scripts exist but related transactions are still missing.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""requests"", RPCArg::Type::ARR, RPCArg::Optional::NO, ""Data to be imported"",
                        {
                            {"""", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, """",
                                {
                                    {""desc"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Descriptor to import. If using descriptor, do not also provide address/scriptPubKey, scripts, or pubkeys""},
                                    {""scriptPubKey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""Type of scriptPubKey (string for script, json for address). Should not be provided if using a descriptor"",
                                        /* oneline_description */ """", {""\\""<script>\\"" | { \\""address\\"":\\""<address>\\"" }"", ""string / json""}
                                    },
                                    {""timestamp"", RPCArg::Type::NUM, RPCArg::Optional::NO, ""Creation time of the key expressed in "" + UNIX_EPOCH_TIME + "",\\n""
        ""                                                              or the string \\""now\\"" to substitute the current synced blockchain time. The timestamp of the oldest\\n""
        ""                                                              key will determine how far back blockchain rescans need to begin for missing wallet transactions.\\n""
        ""                                                              \\""now\\"" can be specified to bypass scanning, for keys which are known to never have been used, and\\n""
        ""                                                              0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest key\\n""
        ""                                                              creation time of all keys being imported by the importmulti call will be scanned."",
                                        /* oneline_description */ """", {""timestamp | \\""now\\"""", ""integer / string""}
                                    },
                                    {""redeemscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH or P2SH-P2WSH address/scriptPubKey""},
                                    {""witnessscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH-P2WSH or P2WSH address/scriptPubKey""},
                                    {""pubkeys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving pubkeys to import. They must occur in P2PKH or P2WPKH scripts. They are not required when the private key is also provided (see the \\""keys\\"" argument)."",
                                        {
                                            {""pubKey"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""keys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving private keys to import. The corresponding public keys must occur in the output or redeemscript."",
                                        {
                                            {""key"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""range"", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, ""If a ranged descriptor is used, this specifies the end or the range (in the form [begin,end]) to import""},
                                    {""internal"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be treated as not incoming payments (also known as change)""},
                                    {""watchonly"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be considered watchonly.""},
                                    {""label"", RPCArg::Type::STR, /* default */ ""''"", ""Label to assign to the address, only allowed with internal=false""},
                                    {""keypool"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether imported public keys should be added to the keypool for when users request new addresses. Only allowed when wallet private keys are disabled""},
                                },
                            },
                        },
                        ""\\""requests\\""""},
                    {""options"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, """",
                        {
                            {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Stating if should rescan the blockchain after all imports""},
                        },
                        ""\\""options\\""""},
                },
                RPCResult{
                    RPCResult::Type::ARR, """", ""Response is an array with the same size as the input that has the execution result"",
                    {
                        {RPCResult::Type::OBJ, """", """",
                        {
                            {RPCResult::Type::BOOL, ""success"", """"},
                            {RPCResult::Type::ARR, ""warnings"", /* optional */ true, """",
                            {
                                {RPCResult::Type::STR, """", """"},
                            }},
                            {RPCResult::Type::OBJ, ""error"", /* optional */ true, """",
                            {
                                {RPCResult::Type::ELISION, """", ""JSONRPC error""},
                            }},
                        }},
                    }
                },
                RPCExamples{
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }, ""
                                          ""{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my 2nd address>\\"" }, \\""label\\"": \\""example 2\\"", \\""timestamp\\"": 1455191480 }]'"") +
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }]' '{ \\""rescan\\"": false}'"")
                },
            }.Check(mainRequest);


    RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    const UniValue& requests = mainRequest.params[0];

    //Default options
    bool fRescan = true;

    if (!mainRequest.params[1].isNull()) {
        const UniValue& options = mainRequest.params[1];

        if (options.exists(""rescan"")) {
            fRescan = options[""rescan""].get_bool();
        }
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t now = 0;
    bool fRunScan = false;
    int64_t nLowestTimestamp = 0;
    UniValue response(UniValue::VARR);
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);
        EnsureWalletIsUnlocked(pwallet);

        // Verify all timestamps are present before importing any keys.
        const Optional<int> tip_height = locked_chain->getHeight();
        now = tip_height ? locked_chain->getBlockMedianTimePast(*tip_height) : 0;
        for (const UniValue& data : requests.getValues()) {
            GetImportTimestamp(data, now);
        }

        const int64_t minimumTimestamp = 1;

        if (fRescan && tip_height) {
            nLowestTimestamp = locked_chain->getBlockTime(*tip_height);
        } else {
            fRescan = false;
        }

        for (const UniValue& data : requests.getValues()) {
            const int64_t timestamp = std::max(GetImportTimestamp(data, now), minimumTimestamp);
            const UniValue result = ProcessImport(pwallet, data, timestamp);
            response.push_back(result);

            if (!fRescan) {
                continue;
            }

            // If at least one request was successful then allow rescan.
            if (result[""success""].get_bool()) {
                fRunScan = true;
            }

            // Get the lowest timestamp.
            if (timestamp < nLowestTimestamp) {
                nLowestTimestamp = timestamp;
            }
        }
    }
    if (fRescan && fRunScan && requests.size()) {
        int64_t scannedTime = pwallet->RescanFromTime(nLowestTimestamp, reserver, true /* update */);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions();
        }

        if (pwallet->IsAbortingRescan()) {
            throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
        }
        if (scannedTime > nLowestTimestamp) {
            std::vector<UniValue> results = response.getValues();
            response.clear();
            response.setArray();
            size_t i = 0;
            for (const UniValue& request : requests.getValues()) {
                // If key creation date is within the successfully scanned
                // range, or if the import result already has an error set, let
                // the result stand unmodified. Otherwise replace the result
                // with an error message.
                if (scannedTime <= GetImportTimestamp(request, now) || results.at(i).exists(""error"")) {
                    response.push_back(results.at(i));
                } else {
                    UniValue result = UniValue(UniValue::VOBJ);
                    result.pushKV(""success"", UniValue(false));
                    result.pushKV(
                        ""error"",
                        JSONRPCError(
                            RPC_MISC_ERROR,
                            strprintf(""Rescan failed for key with creation timestamp %d. There was an error reading a ""
                                      ""block from time %d, which is after or within %d seconds of key creation, and ""
                                      ""could contain transactions pertaining to the key. As a result, transactions ""
                                      ""and coins using this key may not appear in the wallet. This error could be ""
                                      ""caused by pruning or data corruption (see yupostd log for details) and could ""
                                      ""be dealt with by downloading and rescanning the relevant blocks (see -reindex ""
                                      ""and -rescan options)."",
                                GetImportTimestamp(request, now), scannedTime - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)));
                    response.push_back(std::move(result));
                }
                ++i;
            }
        }
    }

    return response;
}
",16243,True,3149.3609507414826,median
"[[generating-svg-chapter]]

== Generating SVG

The previous chapters have described the major features of SVG.(((""generating SVG"", id=""ix_genSVG"", range=""startofrange""))) All the examples have been relatively modest and have been written in an ordinary text editor. For graphics of any great complexity, though, few people will write SVG from scratch. Let’s face it: almost nobody does this by hand. Instead, graphic designers will use some sort of graphic tool that outputs SVG, and programmers will take existing raw data and convert it to SVG with a script. 

If you’re dealing with a graphic program’s output that is already in SVG format, you can sit back and relax; all the heavy lifting has been done for you. If you ever take a look at the SVG that it generated, it may be hard to read. Some programs, for example, may not use groups (the +<g>+ element) efficiently or they may not optimize paths. When you use these programs, you are trading off the ease of generating SVG for the absolute control you have when you write the entire file by hand. Hopefully, with a better understanding of what's going on “under the hood,"" you will be better able to write code to adapt and interact with the graphics program's output.

Generating SVG code from a data file is a trickier topic. The possibilities will depend on what type of data you have to start with and what type of programming languages you can work with.

One option for generating SVG is to build up an SVG document object model using the methods presented in <<svg-dom-chapter>>. link:$$http://d3js.org$$[D3.js], which we alluded to briefly in <<javascript-libraries-section>>, is specifically designed for  using data files to dynamically build SVG charts and graphs in the web browser. Scott Murray's pass:[<ulink role=""orm:hideurl"" url=""http://shop.oreilly.com/product/0636920026938.do""><emphasis>Interactive Data Visualization for the Web</emphasis></ulink>] (O'Reilly) is a good introduction for beginners. There are also many good tutorials by the library's original author, Mike Bostock, and others listed on https://github.com/mbostock/d3/wiki/Tutorials[the project's wiki page].

A different approach to dynamically generating an SVG file is to piece together the markup using the string manipulation and file-writing methods of your favorite pass:[<phrase role=""keep-together"">programming</phrase>] language. The first section of this chapter outlines how you could use a custom program to convert geographical mapping data that’s not in an XML format to an SVG file.

If your data is already in XML format, you may just need to extract the pertinent data and plug it into an SVG framework. In such a case, you can use tools that implement Extensible Stylesheet Language Transformations (XSLT).(((""XSLT (Extensible Stylesheet Language Transformations)""))) XSLT is an XML syntax for defining how to convert one XML file into another. The second part of this chapter shows how to use XSLT to convert an XML-formatted aeronautical weather report to pass:[<phrase role=""keep-together"">SVG</phrase>].

[[data-to-svg-section]]

=== Converting Custom Data to SVG

If anyone lives a life that revolves around graphics display, it’s a mapmaker.(((""generating SVG"", ""converting custom data to SVG"", id=""ix_genSVGconvcus"", range=""startofrange""))) Cartographers are finding XML markup in general and SVG in particular to be excellent vehicles for putting data into a portable format. At present, though, much of the data that is currently available is in custom or proprietary formats. 

One such proprietary format was developed by Environmental Systems Research Institute for use by their ArcInfo Geographic Information System. Data created in this system can be exported in an ASCII _ungenerate_ form.(((""polygon element"", ""ArcInfo Geographic Information in""))) Such a file contains a series of polygon descriptions, followed by a line with the word +END+ on it. Each polygon starts with a line that consists of an integer polygon identification number and the _x_- and _y_-coordinates of the polygon’s centroid. This line is followed by the _x_- and _y_-coordinates of the polygon’s vertices, one vertex per line. A line with the word +END+ on it marks the end of the polygon. Here is a sample file:


----
         1      -0.122432044171565E+03       0.378635608621089E+02
      -0.122418712172884E+03       0.378527169597E+02
      -0.122434402770255E+03       0.378524342437443E+02
      -0.122443301934511E+03       0.378554484803880E+02
      -0.122446316168374E+03       0.378610463416856E+02
      -0.122438565286068E+03       0.378683666259093E+02
      -0.122418712172884E+03       0.378527169591107E+02
END
         2      -122.36                      37.82
      -122.378                     37.826
      -122.377                     37.831
      -122.370                     37.832
      -122.378                     378.826
END
END
----

Converting such a file to SVG is a simple task of inserting the coordinates into the points attribute of +<polygon>+ elements. The only twist is that ARC/INFO stores data in Cartesian coordinates,(((""Cartesian coordinates, converting from""))) so we will have to flip the _y_-coordinates upside-down. The program we’ll describe will take two parameters: the _input-file_ name and the desired  _width_ of the resulting SVG graphic in pixels.

In addition to those parameters, we're going to need a few global variables to keep track of the data:

* ++lineBuffer++, an array of tokens from parsing each line of the file into whitespace-separated words and numbers.
* ++singlePolygon++, an array of coordinates for the current polygon.
* ++polygonList++, an array of +points+ strings for all the polygons.
* ++minX++, ++minY++, ++maxX++, ++maxY++, numbers representing the extreme coordinates observed so far in each direction. The minimum variables should be initialized to equal positive Infinity (or the maximum number possible in the programming language), and the maximum variables to negative Infinity. That way, any finite number compared to them will become the new maximum or minimum.

The following algorithm assumes that you have a way of reading the input file one line at a time, and printing the results to an output stream or file. The exact ways to do so will depend on your programming language, but nearly every language can do both: 

1. Create a utility subroutine that grabs one token at a time from the input file:
+
[subs=""specialcharacters,quotes""]
----
*function get_token() 
{*
  *if (* _lineBuffer_ is empty *) //* out of data?
  *{*
    read the next line from _input-file_;
    get rid of leading and trailing whitespace;
    split on whitespace to create an array of tokens;
    put into _lineBuffer_;
  *}*
  remove first item in _lineBuffer_ and return it
*}*
----

2. The main program (after validating and storing the input parameters and initializing the other variables), uses nested loops to process the data file. The outer loop handles the start and end of each polygon, and the inner loop processes the pairs of coordinates. Each polygon starts with an index number and ends with the token +END+. The file as a whole also ends with an additional +END+. Read an index number, initialize ++singlePolygon++ as a coordinate array, read coordinates until you reach +END+, add that coordinate array to the _polygonList_, and then repeat unless the next token is also +END+:
+
[subs=""specialcharacters,quotes""]
----
open _input-file_;

*while ((polygonNumber = get_token())* is not ""END"" *)*
*{*
  _singlePolygon_ = empty list;

  *while ((xCoord = get_token())* is not ""END"" *)*
  *{
    yCoord = get_token();*
    append (*xCoord, yCoord*) to _singlePolygon_;

    // keep track of minimum and maximum coordinates 
    *minX = min(xCoord, minX);
    maxX = max(xCoord, maxX);
    minY = min(yCoord, minY);
    maxY = max(yCoord, maxY);*
  *}*
  append _singlePolygon_ to _polygonList_;
*}*

close _input-file_ ;
----

3. After processing the input file, ++polygonList++ is an array of arrays of coordinate pairs, and ++minX++, ++minY++, ++maxX++, and ++maxY++ hold the largest and smallest coordinates in each dimension. But before you can start building your SVG, you need to determine an appropriate scale to fit the _x_-range of the data into the pixel width requested by the user. Initialize additional variables to keep track of the input and output pass:[<phrase role=""keep-together"">dimensions</phrase>]:   
+
[subs=""specialcharacters,quotes""]
----
*deltaX = maxX - minX;
deltaY = maxY - minY;
scale = width / deltaX;
height = deltaY * scale;
height = int(height + 0.5);* // round up to integer
----

4. The SVG file itself is constructed by printing markup to a file, substituting in the values from the data:
+
[subs=""specialcharacters,quotes""]
----
open output;

print the following to output, replacing variables in {}
with their values:

  *<!DOCTYPE svg PUBLIC ""-//W3C//DTD SVG 1.1//EN""
  ""http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"">

  <svg width=""* {_width_} *"" height=""* {_height_} *""
    viewBox=""0 0* {_deltaX_}  {_deltaY_} *""
    xmlns=""http://www.w3.org/2000/svg"">
  <title>Map constructed from* {_input-file_} *</title>
  <g style=""fill: none; stroke: black;"">*
----

5. Process the data arrays to create polygon objects:
+
[subs=""specialcharacters,quotes""]
----
*polygonNumber = 1;*
*foreach* _singlePolygon_ in _polygonList_ 
*{*
  *print ' <polyline id=""poly* {_polygonNumber_} *"" points="" ';*
  remove first set of coordinates in _singlePolygon_;
  
  *n = 0;* //coordinate index
  *foreach coordinate* in _singlePolygon_
  *{*
    *if (n % 2 == 1)    // y-coordinate
    {
      coordinate = (maxY - coordinate); // invert y coords
    }
    else
    {
      coordinate = (coordinate - minX);
    }*
    print the coordinate followed by a space;
  *}*

  // To avoid long lines, place only 8 coordinates per line 
    *n = (n + 1) % 8;
    if (n == 0) {* print a newline *}*
  *}*
  *print ' /> ';*    // close off the polyline
  *polygonNumber++;*
}
----

6. Close off open tags and close the file:
+
[subs=""specialcharacters,quotes""]
----
*print ' </g>\\n</svg>\\n ';*
close output;
----

This pseudocode algorithm is a simplified version of a real program written in Perl.
Running the Perl program with the data for the state of Michigan with an output width of 250 pixels produces <<data-to-svg-figure>>. Michigan was chosen because it requires several polygons to draw, and its outline is more visually interesting than that of, say, Colorado. This data came from the US Census Bureau Cartographic Boundary Files website.
////
at link:$$http://www.census.gov/geo/www/cob/$$[].
////

[[data-to-svg-figure]]

.Conversion from ARC/INFO ungenerate to SVG
image::images/sve2_1501.png[]


[[xml-to-svg-section]]

=== Using XSLT to Convert XML Data to SVG

If your data is in XML format, then Extensible Stylesheet Language Transformations (XSLT) may be your best choice for doing the conversion to SVG.(((""generating SVG"", ""converting custom data to SVG"", range=""endofrange"", startref=""ix_genSVGconvcus"")))(((""XSLT (Extensible Stylesheet Language Transformations)"", ""converting XML data to SVG"", id=""ix_XSLT"", range=""startofrange"")))(((""generating SVG"", ""using XSLT to convert XML data to SVG"", id=""ix_genSVGXSLT"", range=""startofrange"")))

[[xml-conversion-task]]

==== Defining the Task

This example uses XSLT to extract information from an XML file and insert it into an SVG file.(((""XSLT (Extensible Stylesheet Language Transformations)"", ""converting XML data to SVG"", ""objectives""))) The source data is a weather report that is retrieved from _http://w1.weather.gov/xml/current_obs/NNNN.xml_, where _NNNN_ represents a four-letter weather pass:[<phrase role=""keep-together"">station</phrase>] identifier. It is formatted as a Weather Observation Markup Format (OMF) document, according to the National Oceanic and Atmospheric Organization’s link:$$http://www.nws.noaa.gov/view/current_observation.xsd$$[definition of the data format]. Here is some sample data (edited for length) from station KSJC:

[source,xml]
----
<current_observation version=""1.0"">
  <credit>NOAA's National Weather Service</credit>
  <credit_URL>http://weather.gov/</credit_URL>
  <location>San Jose International Airport, CA</location>
  <station_id>KSJC</station_id>
  <latitude>37.37</latitude>
  <longitude>-121.93</longitude>
  <observation_time>Last Updated on Jul 15 2014, 7:53 am PDT
    </observation_time>
  <observation_time_rfc822>Tue, 15 Jul 2014 07:53:00 -0700
    </observation_time_rfc822>
  <weather>Overcast</weather>
  <temperature_string>62.0 F (16.7 C)</temperature_string>
  <temp_f>62.0</temp_f>
  <temp_c>16.7</temp_c>
  <wind_string>West at 5.8 MPH (5 KT)</wind_string>
  <wind_dir>West</wind_dir>
  <wind_degrees>290</wind_degrees>
  <wind_mph>5.8</wind_mph>
  <visibility_mi>10.00</visibility_mi>
  <copyright_url>http://weather.gov/disclaimer.html</copyright_url>
</current_observation>

----

The objective is to extract the reporting station, the date and time, temperature, wind speed and direction, and visibility from the report. The data will be filled into the graphic template of <<weather-template-figure>>.

[[weather-template-figure]]

.Graphic weather template
image::images/sve2_1502.png[]

The elements we’re interested in are listed here, along with the plan for displaying them in the final graphic:

+<observation_time_rfc822>+:: In the final graphic, the date and time will be represented in text, and the time will also be shown on an analog clock. The color of the clock face will be light yellow to indicate hours between 6 a.m. and 6 p.m., and light blue for evening and night hours.

+<station_id>+:: The reporting station’s call letters. The final graphic will represent this as text.

+<temp_c>+:: The air temperature in degrees Celsius. This will be displayed by coloring in the thermometer to the appropriate level. If the temperature is greater than 0, the coloring will be red; if less than or equal to 0, it will be blue.

+<wind_degrees>+:: The direction is measured in degrees; 0 indicates wind blowing from true north, and 270 indicates wind from the west. This will be represented by a line on the compass.

+<wind_mph>+:: The wind speed is expressed in miles per hour, which will be converted to meters per second.
  
+<wind_gust_mph>+:: If there are wind gusts, this element will give the speed in miles per hour, which will also be converted to meters per second.

+<visibility_mi>+:: Surface visibility in miles, which will be converted to kilometers. The final graphic will represent this by filling in a horizontal bar. Any visibility above 40 kilometers will be presumed to be unlimited.

[[svgess-CHP-12-SECT-3.2]]

==== How XSLT Works

To convert an OMF source file to its destination SVG format, we will create a list of specifications that tells which elements and attributes in OMF are of interest.(((""XSLT (Extensible Stylesheet Language Transformations)"", ""converting XML data to SVG"", ""how XSLT works""))) These specifications will then detail what SVG elements to generate whenever the processor encounters an item of interest. If you were asking a human to do the transformation by hand, you could write out an English language description:

. Begin a new SVG document by typing this:
+
[source,xml]
----
<!DOCTYPE svg PUBLIC ""-//W3C/DTD SVG 1.0//EN"",
 ""http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"">
----
+
. Go through the source document. As you find each element, look for instructions on how to process it.
+
. To process the +<current_observation>+ element, add the following code to your file, and then process any child elements as specified in comments:
+
[source,xml]
----
<svg viewBox=""0 0 350 200"" height=""200"" width=""350"">
    <!-- process any child elements from <current_observation> -->
</svg>
----
+
. To process a +<station_id>+ element, add this code and fill in the blanks:
+
[source,xml]
----
<text font-size=""10pt"" x=""10"" y=""20"">
    <!-- fill in the value of the element's content -->
</text>
----
+
. To process a +<temp_c>+ element, use its content when following the instructions for “how to draw a thermometer.”
+
. To process a +<wind_dir>+ element, use its contents as you follow the instructions for “how to draw a wind compass.”

Similarly, for each other element type, you would indicate where to find the instructions to follow. Then you'd have supplemental instructions like these:

* To draw a thermometer:
** Calculate the height of the bar as 50 minus the value you got from the caller.
** Determine the appropriate color (+red+ or +blue+) based on whether or not the value is greater than 0. 
** Insert those values where you see the italicized text in the following:
+
[subs=""specialcharacters,quotes""]
----
<path
  d = ""M 25 _height_ 25 90
  A 10 10 0 1 0 35 90
  L 35 _height_ Z""
  style=""stroke: none; fill: _color_ ;""/>
<path
  d= ""M 25 0 25 90 A 10 10 0 1 0 35 90 L 35 0 Z""
  style=""stroke: black; fill: none;""/>
----

There would be equally detailed instructions for “how to draw a wind compass” and all the other elements.

Rather than writing the specifications in English and handing them to a human to perform, you write the specifications in the XSLT markup format. You can then hand the XSLT file, along with the XML file, to an XLST processor, and it will process elements and fill in the blanks to produce an output SVG file.

Here is a quick English-to-XSLT translation guide:

++++
<informaltable
>
<tgroup cols=""2"">
<colspec colname=""col_1"" colwidth=""39%""/>
<colspec colname=""col_2"" colwidth=""46%""/>
<thead>
<row>
<entry>English</entry>
<entry>            XSLT</entry>
</row>
</thead>
<tbody>
<row>
<entry><simpara>Create an output document of a given type</simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:output method=""xml""
  doctype-public=""..."" doctype-system=""...""&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Process an <emphasis><literal>element</literal></emphasis> element</simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:template match=""element""&gt;
  &lt;!-- output to produce --&gt;
&lt;/xsl:template&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Process any <emphasis><literal>items</literal></emphasis> within the  current element</simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:apply-templates select=""items""/&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Fill in the value of an <emphasis><literal>item</literal></emphasis></simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:value-of select=""item""/&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Use the value of an <emphasis><literal>item</literal></emphasis> as a variable named <emphasis><literal>var</literal></emphasis></simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:variable name=""var""&gt;
  &lt;!-- instructions to produce item's value --&gt;
&lt;/xsl:variable&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Call another template named <emphasis>some-name</emphasis>, and give it
a <emphasis>parameter</emphasis> with <emphasis>some-value</emphasis></simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:call-template name=""some-name""&gt;
  &lt;xsl:with-param name=""parameter""
    select=""some-value""/&gt;
&lt;/xsl:call-template&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Add the following content if the data passes a test</simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:if test=""some-test""&gt;
   &lt;!-- content --&gt;
&lt;/xsl:if&gt;</literallayout></entry>
</row>
<row>
<entry><simpara>Add content if data passes a test; otherwise, add other content</simpara></entry>
<entry align=""left"" valign=""top""><literallayout class=""monospaced"">&lt;xsl:choose&gt;
   &lt;xsl:when test=""some-test""&gt;
      &lt;!-- content --&gt;
   &lt;/xsl:when&gt;
   &lt;xsl:otherwise&gt;
      &lt;!-- other content --&gt;
   &lt;/xsl:otherwise&gt;
 &lt;/xsl:choose&gt;</literallayout></entry>
</row>
</tbody>
</tgroup>
</informaltable>
++++


[[developing-xsl-stylesheet-section]]

==== Developing an XSL Stylesheet

We’ll add details as we proceed, but this is more than enough to start.(((""stylesheets"", ""XSLT stylesheet"")))(((""XSLT (Extensible Stylesheet Language Transformations)"", ""converting XML data to SVG"", ""stylesheet structure""))) The XSLT file begins like this, and, for the purposes of this example, is stored in a file named pass:[<phrase role=""keep-together""><emphasis>weather.xsl</emphasis></phrase>]:

++++
<screen language=""xml"">&lt;xsl:stylesheet version=""1.0""
  xmlns:xsl=""http://www.w3.org/1999/XSL/Transform""
  xmlns:xlink=""http://www.w3.org/1999/xlink""
  xmlns=""http://www.w3.org/2000/svg""&gt;

&lt;xsl:output method=""xml"" indent=""yes""
  doctype-public=""-//W3C//DTD SVG 1.0//EN""
  doctype-system=
    ""http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd""/&gt;    <co id=""daXSLs1""/>

&lt;xsl:template match=""current_observation""&gt;     <co id=""daXSLs2""/>
&lt;svg width=""350"" height=""200"" viewBox=""0 0 350 200""
  xmlns=""http://www.w3.org/2000/svg""&gt;
  &lt;g style=""font-family: sans-serif""&gt;

  &lt;!-- Process all child elements --&gt;
  &lt;xsl:apply-templates /&gt;     <co id=""daXSLs3""/>
  &lt;/g&gt;
&lt;/svg&gt;
&lt;/xsl:template&gt;</screen>
<calloutlist>
<callout arearefs=""daXSLs1"">
<para>
The <literal>&lt;xsl:output&gt;</literal> specifies that the output will be an XML file and that it should be indented nicely. It also generates the appropriate <literal>&lt;!DOCTYPE &#8230;&gt;</literal> instruction.
</para>
</callout>
<callout arearefs=""daXSLs2"">
<para>
<literal>&lt;xsl:template&gt;</literal> directs the XSLT processor to generate the specified output whenever it encounters a <literal>&lt;current_observation&gt;</literal> element. This template will be called only once, because there’s only one such element in the source document. It creates the outermost <literal>&lt;svg&gt;</literal> element and a <literal>&lt;g&gt;</literal> element for <phrase role=""keep-together"">later use</phrase>.
</para>
</callout>
<callout arearefs=""daXSLs3"">
<para>
After outputting the <literal>&lt;svg&gt;</literal> and <literal>&lt;g&gt;</literal>, <literal>&lt;xsl:apply-templates&gt;</literal> directs the processor to find any child elements and generate whatever is specified by their <literal>&lt;xsl:template&gt;</literal> elements.
</para>
</callout>
</calloutlist>
++++

This is the markup to process the +station_id+ element:

[source,xml]
----
<xsl:template match=""station_id"">
 <text font-size=""10pt"" x=""10"" y=""20"">
    <xsl:value-of select="".""/>
  </text>
</xsl:template>
----

The +<xsl:value-of>+ inserts the value of the selected item. In this case, the +.+ means “the current element.”

[NOTE]
====
So far, this example uses only element names as the values of a +match+ or +select+. In reality, you can put any XPath expression as a value.(((""XPath""))) XPath is a notation that lets you select parts of an XML document with extreme precision. For example, while processing an XHTML document, you could select only the odd +<td>+ elements that are within +<tr>+ elements that have a +title+ attribute.
====

While it would be possible to output all the relevant SVG for the temperature within one +<xsl:template>+, a modular approach is easier to read and maintain. XSLT lets you create templates that act somewhat like functions; they don’t correspond to any element in the source document, but you may explicitly call them by name and pass parameters to them. Here is the code to draw the thermometer:

[source,xml]
----
<xsl:template match=""temp_c"">
  <xsl:call-template name=""draw-thermometer"">
    <xsl:with-param name=""t"" select="".""/>
  </xsl:call-template>
</xsl:template>
----

If the value of a parameter is an attribute value or the content of an element, the easiest way to set it is with a +select+. Another way to set the value is to put the content between a beginning and ending tag.

Now you can write the template for +draw-thermometer+. The passed-in parameter determines the height to fill the thermometer and whether the thermometer should be filled with red or blue. Let’s build this up in stages. First, extract the parameter and draw the parts that are static:

[language=""xml""]
[subs=""specialcharacters,callouts,quotes""]
----
<xsl:template name=""draw-thermometer"">
  <xsl:param name=""t"" select=""0""/>
  <g id=""thermometer"" transform=""translate(10, 40)"">
    <path id=""thermometer-path"" stroke=""black"" fill=""none""
      d= ""M 25 0 25 90 A 10 10 0 1 0 35 90 L 35 0 Z""/>
      
    <g id=""thermometer-text"" font-size=""8pt"" font-family=""sans-serif"">
      <text x=""20"" y=""95"" text-anchor=""end"">-40</text>
      <text x=""20"" y=""55"" text-anchor=""end"">0</text>
      <text x=""20"" y=""5"" text-anchor=""end"">50</text>
      <text x=""10"" y=""110"" text-anchor=""end"">C</text>
      <text x=""40"" y=""95"">-40</text>
      <text x=""40"" y=""55"">32</text>
      <text x=""40"" y=""5"">120</text>
      <text x=""50"" y=""110"">F</text>
      <text x=""30"" y=""130"" text-anchor=""middle"">Temp.</text>
  </g>
</g>
</xsl:template>
----

The +<xsl:param>+ element lets you provide a default value (in this case, +0+) if no parameter is passed in.

Next, add the code to display the temperature as text. If there was no temperature present, display the value +N/A+. Notice that the parameter name is +t+, but to access its contents, you must say +$t+. This code goes inside the +<g id=""thermometer-text"">+:

[source,xml]
----
<text x=""30"" y=""145"" text-anchor=""middle"">
  <xsl:choose>
    <xsl:when test=""$t != ''"">
      <xsl:value-of select=""round($t)""/>&#176;C /
      <xsl:value-of select=""round($t div 5 * 9 + 32)""/>&#176;F
    </xsl:when>
    <xsl:otherwise>N/A</xsl:otherwise>
  </xsl:choose>
</text>
----

The text is set conditionally with the +<xsl:choose>+ element, which contains one or more +<xsl:when>+ elements. The first one whose +test+ succeeds is the one whose output goes into the final document. The +<xsl:otherwise>+ element is a catch-all in case all the preceding tests fail.

[NOTE]
====
The formula for conversion of Celsius to Fahrenheit uses +div+ for division; this is because the forward slash is already used in XPath to separate levels of element nesting.(((""XPath"")))
====

The next step is to fill the thermometer. This should be done only if the value of the +t+ parameter is not the empty string. The following code uses +<xsl:variable>+ to create a variable named +tint+ and sets its value to either +red+ or +blue+, depending on whether the temperature is above 0 degrees Celsius or not. Variables in XSL are _single-assignment_. Every time the template is called, the variable is set to an initial value, but for the duration of the template, it cannot be changed further. Place this after the closing +</g>+ tag of the +thermometer-text+ group:

[source,xml]
----
<xsl:if test=""$t != ''"">
  <xsl:variable name=""tint"">
  <xsl:choose>
    <xsl:when test=""$t &gt; 0"">red</xsl:when>
    <xsl:otherwise>blue</xsl:otherwise>
  </xsl:choose>
  </xsl:variable>
  <!-- remainder of code -->
</xsl:if>
----

Again, the code uses +<xsl:choose>+ to conditionally set the variable. The +test+ uses the entity reference +&amp;gt;+ for a greater-than symbol to avoid problems with some XSLT processors; if you ever want to produce a less-than symbol, it _must_ be written as +&amp;lt;+.

Here is the remainder of the code for filling the thermometer:

[source,xml]
----
<!-- ""fill"" the thermometer by drawing a solid
  rectangle and clipping it to the shape of
  the thermometer -->
<xsl:variable name=""h"">
  <xsl:choose>
    <xsl:when test=""$t &lt; -55"">
      <xsl:value-of select=""105""/>
    </xsl:when>
    <xsl:when test=""$t &gt; 50"">
      <xsl:value-of select=""0""/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select=""50 - $t""/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>

<clipPath id=""thermoclip"">
  <use xlink:href=""#thermometer-path""/>
</clipPath>
<path d=""M 10 {$h} h40 V 120 h-40 Z""
  fill=""{$tint}"" clip-path=""url(#thermoclip)""/>
----

The +<xsl:choose+> in the preceding code has two +<xsl:when>+ clauses; they limit the height of the “mercury” in case temperatures go above or below the thermometer’s limits. The +<xsl:otherwise>+ clause sets the height for all other in-range temperatures.

When referring to parameters or variables in the values of attributes of the output document, as in the final +<path>+ element, you must enclose them with curly braces.

This would be a good time to test the transformation so far. Before you can test, you have to add an empty template to handle text nodes. XSLT processors are set up with default templates to ensure that they will visit all the elements and text in the source document. The default behavior is to send the text within elements directly to the destination document. In this transformation, you want to throw away any text that you don’t specifically want to process, so there’s an empty template for text nodes; they will not appear in the SVG file. Finally, you need the closing +</xsl:stylesheet>+ tag:

[source,xml]
----
<xsl:template match=""text()""/>

</xsl:stylesheet>
----

Invoke your XSLT processor on the XML file that contains the weather report. The resulting graphic, <<svg-thermometer-figure>>, shows the station name and the thermometer. If you don’t have a standalone XSLT processor, you can add the following lines at the top of the XML file:

[source,xml]
----
<?xml version=""1.0""?>
<?xml-stylesheet type=""text/xsl"" href=""weather.xsl""?>
----

Then open the file in your browser, and it will do the transformation for you.

[[svg-thermometer-figure]]

.XSL-generated SVG file showing thermometer
image::images/sve2_1503.png[]

You have seen that XSLT can do simple arithmetic; it can also do a reasonable amount of string manipulation. Here is the XSLT to display the day and time. It uses the +substring+ function to extract the necessary information.

++++
<screen language=""xml"">&lt;xsl:template match=""observation_time_rfc822""&gt;
  &lt;xsl:variable name=""time"" select="".""/&gt; <co id=""displaytime1""/>

  &lt;text font-size=""10pt"" x=""345"" y=""20"" text-anchor=""end""&gt;
    &lt;xsl:value-of select=""substring($time, 6, 11)""/&gt; <co id=""displaytime2""/>
  &lt;/text&gt;

  &lt;xsl:call-template name=""draw-time-and-clock""&gt; <co id=""displaytime3""/>
    &lt;xsl:with-param name=""hour""
      select=""number(substring($time, 18, 2))""/&gt;
    &lt;xsl:with-param name=""minute""
      select=""number(substring($time, 21, 2))""/&gt;
  &lt;/xsl:call-template&gt;
&lt;/xsl:template&gt;</screen>
<calloutlist>
<callout arearefs=""displaytime1"">
<para>
For convenience, store the string in a variable rather than having to do many <literal>&lt;xsl:value-of&gt;</literal>s.
</para>
</callout>
<callout arearefs=""displaytime2"">
<para>
The <literal>substring()</literal> function needs the string, starting character index, and number of characters to extract. The first character of the string is index number 1, not 0, as in many other programming languages.
</para>
</callout>
<callout arearefs=""displaytime3"">
<para>
Pass the hour and minute to a named template to do the heavy lifting.<indexterm>
  <primary>number function, XSLT</primary>
</indexterm> The <literal>number()</literal> function converts its string parameter to a true numeric value.
</para>
</callout>
</calloutlist>
++++

And here is the template that draws the clock face and displays the time as text (the only new construct here is the +format-number()+ function):

++++
<screen language=""xml"">&lt;xsl:template name=""draw-time-and-clock""&gt;
  &lt;xsl:param name=""hour""&gt;0&lt;/xsl:param&gt;
  &lt;xsl:param name=""minute""&gt;0&lt;/xsl:param&gt;

  &lt;!-- clock face is light yellow from 6 a.m. to 6 p.m.,
       otherwise light blue --&gt;
  &lt;xsl:variable name=""tint""&gt;
    &lt;xsl:choose&gt;
      &lt;xsl:when test=""$hour &amp;gt;= 6 and $hour &amp;lt; 18""
           &gt;#ffffcc&lt;/xsl:when&gt;
      &lt;xsl:otherwise&gt;#ccccff&lt;/xsl:otherwise&gt;
    &lt;/xsl:choose&gt;
  &lt;/xsl:variable&gt;

  &lt;!-- calculate angles for hour and minute hand
    of analog clock --&gt;
  &lt;xsl:variable name=""hourAngle""
    select=""(30 * ($hour mod 12 + $minute div 60)) - 90""/&gt;
  &lt;xsl:variable name=""minuteAngle""
    select=""($minute * 6) - 90""/&gt;

  &lt;text font-size=""10pt"" x=""345"" y=""40"" text-anchor=""end""&gt;
    &lt;xsl:value-of select=""format-number($hour,00)""/&gt; <co id=""drawtimeastext1""/>
    &lt;xsl:text&gt;:&lt;/xsl:text&gt; <co id=""drawtimeastext2""/>
    &lt;xsl:value-of select=""format-number($minute,00)""/&gt;
  &lt;/text&gt;
  &lt;g id=""clock"" transform=""translate(255, 30)""&gt;
    &lt;circle cx=""20"" cy=""20"" r=""20"" fill=""{$tint}""
            stroke=""black""/&gt;
    &lt;line transform=""rotate({$minuteAngle}, 20, 20)""
      x1=""20"" y1=""20"" x2=""38"" y2=""20"" stroke=""black""/&gt;
    &lt;line transform=""rotate({$hourAngle}, 20, 20)""
      x1=""20"" y1=""20"" x2=""33"" y2=""20"" stroke=""black""/&gt;
  &lt;/g&gt;
&lt;/xsl:template&gt;</screen>
<calloutlist>
<callout arearefs=""drawtimeastext1"">
<para>
The <literal>format-number($hour,<replaceable>00</replaceable>)</literal> ensures that the output will have a leading zero if it is less than two digits long.
</para>
</callout>
<callout arearefs=""drawtimeastext2"">
<para>
The <literal>&lt;xsl:text&gt;</literal> element places its contents, which must be pure text, into the output document verbatim. Using <literal>&lt;xsl:text&gt;</literal> helps avoid problems with whitespace; if I had not used it, the newline and indentation would have made its way into the resultant SVG <literal>&lt;text&gt;</literal> element, which would have produced extra space around the colon in the final graphic.
</para>
</callout>
</calloutlist>
++++ 

Here is the markup to draw the wind speed indicator:

++++
<screen language=""xml"">&lt;xsl:template match=""wind_degrees""&gt;
  &lt;xsl:call-template name=""draw-wind""&gt;
    &lt;xsl:with-param name=""dir"" select=""number(.)""/&gt;
    &lt;xsl:with-param name=""speed""
      select=""number(../wind_mph) * 1609.344 div 3600""/&gt; <co id=""windspeedindicator1""/>
    &lt;xsl:with-param name=""gust""
      select=""number(following-sibling::wind_gust_mph) *
        1609.344 div 3600""/&gt;
  &lt;/xsl:call-template&gt;
&lt;/xsl:template&gt;

&lt;xsl:template name=""draw-wind""&gt;
  &lt;xsl:param name=""dir""&gt;0&lt;/xsl:param&gt;
  &lt;xsl:param name=""speed""&gt;0&lt;/xsl:param&gt;
  &lt;xsl:param name=""gust""&gt;0&lt;/xsl:param&gt;

  &lt;g id=""compass"" font-size=""8pt"" font-family=""sans-serif""
    transform=""translate(110, 70)""&gt;
    &lt;circle cx=""40"" cy=""40"" r=""30"" stroke=""black"" fill=""none""/&gt;
    &lt;!-- tick marks at cardinal directions --&gt;
    &lt;path stroke=""black"" fill=""none""
      d= ""M 40 10 L 40 14
      M 70 40 L 66 40
      M 40 70 L 40 66
      M 10 40 L 14 40""/&gt;
    &lt;xsl:if test=""$speed &amp;gt;= 0""&gt;
      &lt;path d=""M 40 40 h 25""
        fill=""none"" stroke=""black""
        transform=""rotate({$dir - 90},40,40)""/&gt; <co id=""windspeedindicator2""/>
    &lt;/xsl:if&gt;
    &lt;text x=""40"" y=""9"" text-anchor=""middle""&gt;N&lt;/text&gt;
    &lt;text x=""73"" y=""44""&gt;E&lt;/text&gt;
    &lt;text x=""40"" y=""80"" text-anchor=""middle""&gt;S&lt;/text&gt;
    &lt;text x=""8"" y=""44"" text-anchor=""end""&gt;W&lt;/text&gt;
    &lt;text x=""40"" y=""100"" text-anchor=""middle""&gt;Wind (m/sec)&lt;/text&gt;
    &lt;text x=""40"" y=""115"" text-anchor=""middle""&gt; <co id=""windspeedindicator3""/>
      &lt;xsl:choose&gt;
        &lt;xsl:when test=""$speed &amp;gt;= 0""&gt;
          &lt;xsl:value-of select=""format-number($speed, <emphasis>0.</emphasis>)""/&gt;
        &lt;/xsl:when&gt;
        &lt;xsl:otherwise&gt;N/A&lt;/xsl:otherwise&gt;
      &lt;/xsl:choose&gt;
      &lt;xsl:if test=""$gust &amp;gt; 0""&gt;
        &lt;xsl:text&gt; - &lt;/xsl:text&gt;
        &lt;xsl:value-of select=""format-number($gust, <emphasis>0.</emphasis>)""/&gt;
      &lt;/xsl:if&gt;
    &lt;/text&gt;
  &lt;/g&gt;
&lt;/xsl:template&gt;</screen>
<calloutlist>
<callout arearefs=""windspeedindicator1"">
<para>
Here is a more complex XPath expression. <literal>..</literal> means “this node’s parent,” so <literal>../wind_mph</literal> will find all the <literal>&lt;wind_mph&gt;</literal> elements that are children of the parent of the <literal>&lt;wind_degree&gt;</literal> element (in this XML file, there is only one such element). The expression that gets the wind gust (if any) uses the more verbose <literal>following-sibling::</literal> specification.<indexterm>
  <primary>XPath</primary>
</indexterm>
</para>
</callout>
<callout arearefs=""windspeedindicator2"">
<para>
The NOAA specification says that a true north wind is 360 degrees, with 0 degrees implying no wind. You have to subtract 90 degrees, because “north” is –90 degrees in SVG.
</para>
</callout>
<callout arearefs=""windspeedindicator3"">
<para>
This logic for displaying the wind speed (and gusts) as text works even if there is no <literal>&lt;wind_mph&gt;</literal> or <literal>&lt;wind_gust_mph&gt;</literal> element in the weather report. When a nonexistent element’s content is converted to a number, the result is <literal>NaN</literal> (Not a Number). When you do any comparison with <literal>NaN</literal>, the result is <emphasis>always</emphasis> false. Thus, if there is no <literal>&lt;wind_mph&gt;</literal>, the resulting text is <literal>N/A</literal>, and when there is no <literal>&lt;wind_gust_mph&gt;</literal>, the dash and second number are never output.
</para>
</callout>
</calloutlist>
++++


Here are the XSLT commands to draw the visibility bar. The first template converts the visibility to kilometers as it passes it to the second template. The visibility bar is 100 pixels wide, so any visibility greater than 40 km is set to 100; anything less is scaled:

++++
<screen language=""xml"">&lt;xsl:template match=""visibility_mi""&gt;
  &lt;xsl:call-template name=""draw-visibility""&gt;
    &lt;xsl:with-param name=""v"" select=""number(.) * 1.609344""/&gt; <co id=""visibilitybar1""/>
  &lt;/xsl:call-template&gt;
&lt;/xsl:template&gt;

&lt;xsl:template name=""draw-visibility""&gt;
  &lt;xsl:param name=""v""&gt;0&lt;/xsl:param&gt;
  &lt;g id=""visbar"" transform=""translate(220,110)""
    font-size=""8pt"" text-anchor=""middle""&gt;

  &lt;!-- fill in the rectangle if there is a visibility value --&gt;
  &lt;xsl:if test=""$v &amp;gt;= 0""&gt;
    &lt;xsl:variable name=""width""&gt; <co id=""visibilitybar2""/>
      &lt;xsl:choose&gt;
      &lt;xsl:when test=""$v &amp;gt; 40""&gt;100&lt;/xsl:when&gt;
      &lt;xsl:otherwise&gt;
        &lt;xsl:value-of select=""$v * 100.0 div 40.0""/&gt;
      &lt;/xsl:otherwise&gt;
      &lt;/xsl:choose&gt;
    &lt;/xsl:variable&gt;
    &lt;rect style=""fill:green; stroke:none;""
      x=""0"" y=""0"" width=""{$width}"" height=""20""/&gt;
  &lt;/xsl:if&gt;

  &lt;rect x=""0"" y=""0"" width=""100"" height=""20""
        style=""stroke:black; fill:none""/&gt;

  &lt;path fill=""none"" stroke=""black""
    d=""M 25 20 L 25 25 M 50 20 L 50 25 M 75 20 L 75 25""/&gt;

  &lt;text x=""0"" y=""35""&gt;0&lt;/text&gt;
  &lt;text x=""25"" y=""35""&gt;10&lt;/text&gt;
  &lt;text x=""50"" y=""35""&gt;20&lt;/text&gt;
  &lt;text x=""75"" y=""35""&gt;30&lt;/text&gt;
  &lt;text x=""100"" y=""35""&gt;40+&lt;/text&gt;
  &lt;text x=""50"" y=""60""&gt;
    Visibility (km)
  &lt;/text&gt;
  &lt;text x=""50"" y=""75""&gt;
    &lt;xsl:choose&gt;
       &lt;xsl:when test=""$v &amp;gt;= 0""&gt;
         &lt;xsl:value-of select=""format-number($v,'0.###')""/&gt; <co id=""visibilitybar3""/>
      &lt;/xsl:when&gt;
      &lt;xsl:otherwise&gt;N/A&lt;/xsl:otherwise&gt;
    &lt;/xsl:choose&gt;
  &lt;/text&gt;
&lt;/g&gt;
&lt;/xsl:template&gt;</screen>
<calloutlist>
<callout arearefs=""visibilitybar1"">
<para>
The first template passes the visibility, converted to kilometers, to the next template.
</para>
</callout>
<callout arearefs=""visibilitybar2"">
<para>
The visibility bar is 100 pixels wide. Visibility greater than 40 km is set to 100; anything less than that is scaled to 100 pixels.
</para>
</callout>
<callout arearefs=""visibilitybar3"">
<para>
This format string will print a leading zero before the decimal point and three digits after the decimal point.
</para>
</callout>
</calloutlist>
++++

Putting this all together produces <<svg-complete-weather-figure>>.

This is only a small sample of what you can do with XSLT. For more information, get pass:[<ulink role=""orm:hideurl"" url=""http://shop.oreilly.com/product/9780596527211.do""><emphasis>XSLT</emphasis></ulink>] by Doug Tidwell (O’Reilly). Chapter 9 of that marvelous book also contains an example of using XSLT to generate SVG from an XML file. If you’re serious about manipulating XML, you would be well advised to have that book on your shelf.
(((""generating SVG"", ""using XSLT to convert XML data to SVG"", range=""endofrange"", startref=""ix_genSVGXSLT"")))(((""XSLT (Extensible Stylesheet Language Transformations)"", ""converting XML data to SVG"", range=""endofrange"", startref=""ix_XSLT"")))(((""generating SVG"", range=""endofrange"", startref=""ix_genSVG"")))

[[svg-complete-weather-figure]]
.XSLT-generated SVG file showing complete data
image::images/sve2_1504.png[]",12093,False,2057.219685310483,median
"// Copyright (c) Facebook, Inc. and its affiliates.
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.

#include ""ResourceManager.h""

#include <Corrade/Containers/ArrayViewStl.h>
#include <Corrade/Containers/PointerStl.h>
#include <Corrade/PluginManager/Manager.h>
#include <Corrade/PluginManager/PluginMetadata.h>
#include <Corrade/Utility/Assert.h>
#include <Corrade/Utility/ConfigurationGroup.h>
#include <Corrade/Utility/Debug.h>
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/Directory.h>
#include <Corrade/Utility/String.h>
#include <Magnum/EigenIntegration/GeometryIntegration.h>
#include <Magnum/EigenIntegration/Integration.h>
#include <Magnum/GL/Context.h>
#include <Magnum/GL/Extensions.h>
#include <Magnum/ImageView.h>
#include <Magnum/Math/FunctionsBatch.h>
#include <Magnum/Math/Range.h>
#include <Magnum/Math/Tags.h>
#include <Magnum/MeshTools/Compile.h>
#include <Magnum/PixelFormat.h>
#include <Magnum/SceneGraph/Object.h>
#include <Magnum/Shaders/Flat.h>
#include <Magnum/Trade/AbstractImporter.h>
#include <Magnum/Trade/ImageData.h>
#include <Magnum/Trade/MeshObjectData3D.h>
#include <Magnum/Trade/PbrMetallicRoughnessMaterialData.h>
#include <Magnum/Trade/PhongMaterialData.h>
#include <Magnum/Trade/SceneData.h>
#include <Magnum/Trade/TextureData.h>

#include ""esp/geo/geo.h""
#include ""esp/gfx/GenericDrawable.h""
#include ""esp/gfx/MaterialUtil.h""
#include ""esp/io/io.h""
#include ""esp/io/json.h""
#include ""esp/physics/PhysicsManager.h""
#include ""esp/scene/SceneConfiguration.h""
#include ""esp/scene/SceneGraph.h""

#include ""esp/nav/PathFinder.h""

#ifdef ESP_BUILD_WITH_BULLET
#include ""esp/physics/bullet/BulletPhysicsManager.h""
#endif

#include ""CollisionMeshData.h""
#include ""GenericInstanceMeshData.h""
#include ""GenericMeshData.h""
#include ""MeshData.h""

#ifdef ESP_BUILD_PTEX_SUPPORT
#include ""PTexMeshData.h""
#include ""esp/gfx/PTexMeshDrawable.h""
#include ""esp/gfx/PTexMeshShader.h""
#endif

namespace Cr = Corrade;
namespace Mn = Magnum;

namespace esp {
using metadata::attributes::AbstractObjectAttributes;
using metadata::attributes::CubePrimitiveAttributes;
using metadata::attributes::ObjectAttributes;
using metadata::attributes::PhysicsManagerAttributes;
using metadata::attributes::StageAttributes;
using metadata::managers::AssetAttributesManager;
using metadata::managers::ObjectAttributesManager;
using metadata::managers::PhysicsAttributesManager;
using metadata::managers::StageAttributesManager;

namespace assets {

// static constexpr arrays require redundant definitions until C++17
constexpr char ResourceManager::NO_LIGHT_KEY[];
constexpr char ResourceManager::DEFAULT_LIGHTING_KEY[];
constexpr char ResourceManager::DEFAULT_MATERIAL_KEY[];
constexpr char ResourceManager::WHITE_MATERIAL_KEY[];
constexpr char ResourceManager::PER_VERTEX_OBJECT_ID_MATERIAL_KEY[];
ResourceManager::ResourceManager()
    :
#ifdef MAGNUM_BUILD_STATIC
      // avoid using plugins that might depend on different library versions
      importerManager_(""nonexistent"")
#endif
{

  initDefaultLightSetups();
  initDefaultMaterials();
  buildImportersAndAttributesManagers();
}  // namespace assets

void ResourceManager::buildImportersAndAttributesManagers() {
  assetAttributesManager_ = AssetAttributesManager::create();
  objectAttributesManager_ = ObjectAttributesManager::create();
  objectAttributesManager_->setAssetAttributesManager(assetAttributesManager_);
  physicsAttributesManager_ =
      PhysicsAttributesManager::create(objectAttributesManager_);
  stageAttributesManager_ = StageAttributesManager::create(
      objectAttributesManager_, physicsAttributesManager_);

  // instantiate a primitive importer
  CORRADE_INTERNAL_ASSERT_OUTPUT(
      primitiveImporter_ =
          importerManager_.loadAndInstantiate(""PrimitiveImporter""));
  // necessary for importer to be usable
  primitiveImporter_->openData("""");
  // instantiate importer for file load
  CORRADE_INTERNAL_ASSERT_OUTPUT(
      fileImporter_ = importerManager_.loadAndInstantiate(""AnySceneImporter""));

}  // buildImportersAndAttributesManagers

void ResourceManager::initDefaultPrimAttributes() {
  // by this point, we should have a GL::Context so load the bb primitive.
  // TODO: replace this completely with standard mesh (i.e. treat the bb
  // wireframe cube no differently than other primivite-based rendered
  // objects)
  auto cubeMeshName =
      assetAttributesManager_
          ->getObjectCopyByHandle<CubePrimitiveAttributes>(""cubeWireframe"")
          ->getPrimObjClassName();

  auto wfCube = primitiveImporter_->mesh(cubeMeshName);
  primitive_meshes_[nextPrimitiveMeshId++] =
      std::make_unique<Magnum::GL::Mesh>(Magnum::MeshTools::compile(*wfCube));

}  // initDefaultPrimAttributes

void ResourceManager::initPhysicsManager(
    std::shared_ptr<physics::PhysicsManager>& physicsManager,
    bool isEnabled,
    scene::SceneNode* parent,
    const Attrs::PhysicsManagerAttributes::ptr& physicsManagerAttributes) {
  //! PHYSICS INIT: Use the passed attributes to initialize physics engine
  bool defaultToNoneSimulator = true;
  if (isEnabled) {
    if (physicsManagerAttributes->getSimulator().compare(""bullet"") == 0) {
#ifdef ESP_BUILD_WITH_BULLET
      physicsManager.reset(
          new physics::BulletPhysicsManager(*this, physicsManagerAttributes));
      defaultToNoneSimulator = false;
#else
      LOG(WARNING)
          << "":\\n---\\nPhysics was enabled and Bullet physics engine was ""
             ""specified, but the project is built without Bullet support. ""
             ""Objects added to the scene will be restricted to kinematic ""
             ""updates ""
             ""only. Reinstall with --bullet to enable Bullet dynamics.\\n---"";
#endif
    }
  }
  // reset to base PhysicsManager to override previous as default behavior
  // if the desired simulator is not supported reset to ""none"" in metaData
  if (defaultToNoneSimulator) {
    physicsManagerAttributes->setSimulator(""none"");
    physicsManager.reset(
        new physics::PhysicsManager(*this, physicsManagerAttributes));
  }

  // build default primitive asset templates, and default primitive object
  // templates
  initDefaultPrimAttributes();

  // initialize the physics simulator
  physicsManager->initPhysics(parent);
}  // ResourceManager::initPhysicsManager

bool ResourceManager::loadStage(
    const StageAttributes::ptr& stageAttributes,
    std::shared_ptr<physics::PhysicsManager> _physicsManager,
    esp::scene::SceneManager* sceneManagerPtr,
    std::vector<int>& activeSceneIDs,
    bool loadSemanticMesh) {
  // create AssetInfos here for each potential mesh file for the scene, if they
  // are unique.
  bool buildCollisionMesh =
      ((_physicsManager != nullptr) &&
       (_physicsManager->getInitializationAttributes()->getSimulator().compare(
            ""none"") != 0));
  const Magnum::ResourceKey& renderLightSetup(stageAttributes->getLightSetup());
  std::map<std::string, AssetInfo> assetInfoMap =
      createStageAssetInfosFromAttributes(stageAttributes, buildCollisionMesh,
                                          loadSemanticMesh);

  auto& sceneGraph = sceneManagerPtr->getSceneGraph(activeSceneIDs[0]);
  auto& rootNode = sceneGraph.getRootNode();
  auto& drawables = sceneGraph.getDrawables();

  // bool computeAbsoluteAABBs =
  //   (info.type == AssetType::FRL_PTEX_MESH ||
  //    info.type == AssetType::MP3D_MESH || info.type == AssetType::UNKNOWN ||
  //    (info.type == AssetType::INSTANCE_MESH && splitSemanticMesh));

  AssetInfo renderInfo = assetInfoMap.at(""render"");
  // pass nullptr as physics manager for render mesh, since we are loading
  // collision mesh next
  bool renderMeshSuccess =
      loadStageInternal(renderInfo,         // AssetInfo
                        &rootNode,          // parent scene node
                        &drawables,         //  drawable group
                        true,               // compute Absolute AABBs or not
                        false,              // split semantic mesh or not
                        renderLightSetup);  // light setup

  if (!renderMeshSuccess) {
    LOG(ERROR)
        << "" ResourceManager::loadStage : Stage render mesh load failed, ""
           ""Aborting scene initialization."";
    return false;
  }
  // declare mesh group variable
  std::vector<CollisionMeshData> meshGroup;
  AssetInfo& infoToUse = renderInfo;
  if (assetInfoMap.count(""collision"")) {
    AssetInfo colInfo = assetInfoMap.at(""collision"");
    // should this be checked to make sure we do not reload?
    bool collisionMeshSuccess =
        loadStageInternal(colInfo,            // AssetInfo
                          nullptr,            // parent scene node
                          nullptr,            // drawable group
                          false,              // compute absolute AABBs or not
                          false,              // split semantic mesh or not
                          renderLightSetup);  // light setup

    if (!collisionMeshSuccess) {
      LOG(ERROR) << "" ResourceManager::loadStage : Stage collision mesh ""
                    ""load failed.  Aborting scene initialization."";
      return false;
    }
    // if we have a collision mesh, and it does not exist already as a
    // collision object, add it
    if (colInfo.filepath.compare(EMPTY_SCENE) != 0) {
      infoToUse = colInfo;
    }  // if not colInfo.filepath.compare(EMPTY_SCENE)
  }    // if collision mesh desired
  // build the appropriate mesh groups, either for the collision mesh, or, if
  // the collision mesh is empty scene

  if ((_physicsManager != nullptr) &&
      (infoToUse.filepath.compare(EMPTY_SCENE) != 0)) {
    bool success = buildMeshGroups(infoToUse, meshGroup);
    if (!success) {
      return false;
    }
    //! Add to physics manager - will only be null for certain tests
    // Either add with pre-built meshGroup if collision assets are loaded
    // or empty vector for mesh group - this should only be the case if
    // we are using None-type physicsManager.
    bool sceneSuccess =
        _physicsManager->addStage(stageAttributes->getHandle(), meshGroup);
    if (!sceneSuccess) {
      LOG(ERROR) << ""ResourceManager::loadStage : Adding Stage ""
                 << stageAttributes->getHandle()
                 << "" to PhysicsManager failed. Aborting scene initialization."";
      return false;
    }
  }

  bool semanticStageSuccess = false;
  // set equal to current Simulator::activeSemanticSceneID_ value
  int activeSemanticSceneID = activeSceneIDs[0];
  // if semantic scene load is requested and possible
  if (assetInfoMap.count(""semantic"")) {
    // check if file names exist
    AssetInfo semanticInfo = assetInfoMap.at(""semantic"");
    auto semanticStageFilename = semanticInfo.filepath;
    if (Cr::Utility::Directory::exists(semanticStageFilename)) {
      LOG(INFO) << ""ResourceManager::loadStage : Loading Semantic Stage mesh : ""
                << semanticStageFilename;
      activeSemanticSceneID = sceneManagerPtr->initSceneGraph();
      bool splitSemanticMesh = stageAttributes->getFrustrumCulling();

      auto& semanticSceneGraph =
          sceneManagerPtr->getSceneGraph(activeSemanticSceneID);
      auto& semanticRootNode = semanticSceneGraph.getRootNode();
      auto& semanticDrawables = semanticSceneGraph.getDrawables();
      bool computeSemanticAABBs = splitSemanticMesh;

      semanticStageSuccess = loadStageInternal(
          semanticInfo,          // AssetInfo
          &semanticRootNode,     // parent scene node
          &semanticDrawables,    // drawable group
          computeSemanticAABBs,  // compute absolute AABBs or not
          splitSemanticMesh);    // split semantic mesh or not
      // regardless of load failure, original code still changed
      // activeSemanticSceneID_
      activeSceneIDs[1] = activeSemanticSceneID;
      if (!semanticStageSuccess) {
        LOG(ERROR) << "" ResourceManager::loadStage : Semantic Stage mesh ""
                      ""load failed."";
        return false;
      } else {
        LOG(INFO) << ""ResourceManager::loadStage : Semantic Stage mesh : ""
                  << semanticStageFilename << "" loaded."";
      }
    } else {  // semantic file name does not exist but house does
      LOG(WARNING)
          << ""ResourceManager::loadStage : Not loading semantic mesh - ""
             ""File Name : ""
          << semanticStageFilename << "" does not exist."";
    }
  } else {  // not wanting to create semantic mesh
    LOG(INFO) << ""ResourceManager::loadStage : Not loading semantic mesh"";
  }
  // save active semantic scene ID so that simulator can consume
  activeSceneIDs[1] = activeSemanticSceneID;

  return true;
}  // ResourceManager::loadScene

bool ResourceManager::buildMeshGroups(
    const AssetInfo& info,
    std::vector<CollisionMeshData>& meshGroup) {
  if (collisionMeshGroups_.count(info.filepath) == 0) {
    //! Collect collision mesh group
    bool colMeshGroupSuccess = false;
    if (info.type == AssetType::INSTANCE_MESH) {
      // PLY Instance mesh
      colMeshGroupSuccess =
          buildStageCollisionMeshGroup<GenericInstanceMeshData>(info.filepath,
                                                                meshGroup);
    } else if (info.type == AssetType::MP3D_MESH ||
               info.type == AssetType::UNKNOWN) {
      // GLB Mesh
      colMeshGroupSuccess = buildStageCollisionMeshGroup<GenericMeshData>(
          info.filepath, meshGroup);
    }
    // TODO : PTEX collision support

    // failure during build of collision mesh group
    if (!colMeshGroupSuccess) {
      LOG(ERROR) << ""ResourceManager::loadStage : Stage "" << info.filepath
                 << "" Collision mesh load failed. Aborting scene ""
                    ""initialization."";
      return false;
    }
    //! Add scene meshgroup to collision mesh groups
    collisionMeshGroups_.emplace(info.filepath, meshGroup);
  } else {
    // collision meshGroup already exists from prior load
    meshGroup = collisionMeshGroups_.at(info.filepath);
  }
  return true;
}  // ResourceManager::buildMeshGroups

std::map<std::string, AssetInfo>
ResourceManager::createStageAssetInfosFromAttributes(
    const StageAttributes::ptr& stageAttributes,
    bool createCollisionInfo,
    bool createSemanticInfo) {
  std::map<std::string, AssetInfo> resMap;
  auto frame =
      buildFrameFromAttributes(stageAttributes, stageAttributes->getOrigin());
  float virtualUnitToMeters = stageAttributes->getUnitsToMeters();
  // create render asset info
  auto renderType =
      static_cast<AssetType>(stageAttributes->getRenderAssetType());
  AssetInfo renderInfo{
      renderType,                               // type
      stageAttributes->getRenderAssetHandle(),  // file path
      frame,                                    // frame
      virtualUnitToMeters,                      // virtualUnitToMeters
      stageAttributes->getRequiresLighting()    // requiresLighting
  };
  resMap[""render""] = renderInfo;
  if (createCollisionInfo) {
    // create collision asset info if requested
    auto colType =
        static_cast<AssetType>(stageAttributes->getCollisionAssetType());
    AssetInfo collisionInfo{
        colType,                                     // type
        stageAttributes->getCollisionAssetHandle(),  // file path
        frame,                                       // frame
        virtualUnitToMeters,                         // virtualUnitToMeters
        false                                        // requiresLighting
    };
    resMap[""collision""] = collisionInfo;
  }
  if (createSemanticInfo) {
    // create semantic asset info if requested
    auto semanticType =
        static_cast<AssetType>(stageAttributes->getSemanticAssetType());
    AssetInfo semanticInfo{
        semanticType,                               // type
        stageAttributes->getSemanticAssetHandle(),  // file path
        frame,                                      // frame
        virtualUnitToMeters,                        // virtualUnitToMeters
        false                                       // requiresLighting

    };
    resMap[""semantic""] = semanticInfo;
  }
  return resMap;
}  // ResourceManager::createStageAssetInfosFromAttributes

esp::geo::CoordinateFrame ResourceManager::buildFrameFromAttributes(
    const AbstractObjectAttributes::ptr& attribs,
    const Magnum::Vector3& origin) {
  const vec3f upEigen{
      Mn::EigenIntegration::cast<vec3f>(attribs->getOrientUp())};
  const vec3f frontEigen{
      Mn::EigenIntegration::cast<vec3f>(attribs->getOrientFront())};
  if (upEigen.isOrthogonal(frontEigen)) {
    const vec3f originEigen{Mn::EigenIntegration::cast<vec3f>(origin)};
    esp::geo::CoordinateFrame frame{upEigen, frontEigen, originEigen};
    return frame;
  } else {
    LOG(INFO) << ""ResourceManager::buildFrameFromAttributes : Specified frame ""
                 ""in Attributes : ""
              << attribs->getHandle()
              << "" is not orthogonal, so returning default frame."";
    esp::geo::CoordinateFrame frame;
    return frame;
  }
}  // ResourceManager::buildCoordFrameFromAttribVals

bool ResourceManager::loadStageInternal(
    const AssetInfo& info,
    scene::SceneNode* parent /* = nullptr */,
    DrawableGroup* drawables /* = nullptr */,
    bool computeAbsoluteAABBs /*  = false */,
    bool splitSemanticMesh /* = true */,
    const Mn::ResourceKey& lightSetup /* = Mn::ResourceKey{NO_LIGHT_KEY})*/) {
  // scene mesh loading
  const std::string& filename = info.filepath;
  bool meshSuccess = true;
  if (info.filepath.compare(EMPTY_SCENE) != 0) {
    if (!Cr::Utility::Directory::exists(filename)) {
      LOG(ERROR)
          << ""ResourceManager::loadStageInternal : Cannot find scene file ""
          << filename;
      meshSuccess = false;
    } else {
      if (info.type == AssetType::INSTANCE_MESH) {  // semantic
        meshSuccess = loadInstanceMeshData(
            info, parent, drawables, computeAbsoluteAABBs, splitSemanticMesh);
      } else if (info.type == AssetType::FRL_PTEX_MESH) {
        meshSuccess = loadPTexMeshData(info, parent, drawables);
      } else if (info.type == AssetType::SUNCG_SCENE) {
        meshSuccess = loadSUNCGHouseFile(info, parent, drawables);
      } else if (info.type == AssetType::MP3D_MESH) {
        meshSuccess = loadGeneralMeshData(info, parent, drawables,
                                          computeAbsoluteAABBs, lightSetup);
      } else {
        // Unknown type, just load general mesh data
        meshSuccess = loadGeneralMeshData(info, parent, drawables,
                                          computeAbsoluteAABBs, lightSetup);
      }
    }
  } else {
    LOG(INFO) << ""ResourceManager::loadStageInternal : Loading empty scene for ""
              << filename;
    // EMPTY_SCENE (ie. ""NONE"") string indicates desire for an empty scene (no
    // scene mesh): welcome to the void
  }

  return meshSuccess;

}  // ResourceManager::loadStageInternal

template <class T>
bool ResourceManager::buildStageCollisionMeshGroup(
    const std::string& filename,
    std::vector<CollisionMeshData>& meshGroup) {
  // TODO : refactor to manage any mesh groups, not just scene

  //! Collect collision mesh group
  const MeshMetaData& metaData = getMeshMetaData(filename);
  auto indexPair = metaData.meshIndex;
  int start = indexPair.first;
  int end = indexPair.second;
  for (int mesh_i = start; mesh_i <= end; ++mesh_i) {
    T* rawMeshData = dynamic_cast<T*>(meshes_[mesh_i].get());
    if (rawMeshData == nullptr) {
      // means dynamic cast failed
      Cr::Utility::Debug()
          << ""ResourceManager::buildStageCollisionMeshGroup : ""
             ""AssetInfo::AssetType ""
             ""type error: unsupported mesh type, aborting. Try running ""
             ""without \\""--enable-physics\\"" and consider logging an issue."";
      return false;
    }
    CollisionMeshData& colMeshData = rawMeshData->getCollisionMeshData();
    meshGroup.push_back(colMeshData);
  }  // for each mesh

  return true;
}  // ResourceManager::buildStageCollisionMeshGroup

bool ResourceManager::loadObjectMeshDataFromFile(
    const std::string& filename,
    const std::string& objectTemplateHandle,
    const std::string& meshType,
    const bool requiresLighting) {
  bool success = false;
  if (!filename.empty()) {
    AssetInfo meshInfo{AssetType::UNKNOWN, filename};
    meshInfo.requiresLighting = requiresLighting;
    success = loadGeneralMeshData(meshInfo);
    if (!success) {
      LOG(ERROR) << ""Failed to load a physical object ("" << objectTemplateHandle
                 << "")'s "" << meshType << "" mesh from file : "" << filename;
    }
  }
  return success;
}  // loadObjectMeshDataFromFile

Magnum::Range3D ResourceManager::computeMeshBB(BaseMesh* meshDataGL) {
  CollisionMeshData& meshData = meshDataGL->getCollisionMeshData();
  return Mn::Math::minmax(meshData.positions);
}

#ifdef ESP_BUILD_PTEX_SUPPORT
void ResourceManager::computePTexMeshAbsoluteAABBs(
    BaseMesh& baseMesh,
    const std::vector<StaticDrawableInfo>& staticDrawableInfo) {
  std::vector<Mn::Matrix4> absTransforms =
      computeAbsoluteTransformations(staticDrawableInfo);

  CORRADE_ASSERT(
      absTransforms.size() == staticDrawableInfo.size(),
      ""ResourceManager::computePTexMeshAbsoluteAABBs: number of ""
      ""transformations does not match number of drawables. Aborting."", );

  // obtain the sub-meshes within the ptex mesh
  PTexMeshData& ptexMeshData = dynamic_cast<PTexMeshData&>(baseMesh);
  const std::vector<PTexMeshData::MeshData>& submeshes = ptexMeshData.meshes();

  for (uint32_t iEntry = 0; iEntry < absTransforms.size(); ++iEntry) {
    // convert std::vector<vec3f> to std::vector<Mn::Vector3>
    const PTexMeshData::MeshData& submesh =
        submeshes[staticDrawableInfo[iEntry].meshID];
    std::vector<Mn::Vector3> pos{submesh.vbo.begin(), submesh.vbo.end()};

    // transform the vertex positions to the world space
    Mn::MeshTools::transformPointsInPlace(absTransforms[iEntry], pos);

    scene::SceneNode& node = staticDrawableInfo[iEntry].node;
    node.setAbsoluteAABB(Mn::Math::minmax(pos));
  }
}  // ResourceManager::computePTexMeshAbsoluteAABBs
#endif

void ResourceManager::computeGeneralMeshAbsoluteAABBs(
    const std::vector<StaticDrawableInfo>& staticDrawableInfo) {
  std::vector<Mn::Matrix4> absTransforms =
      computeAbsoluteTransformations(staticDrawableInfo);

  CORRADE_ASSERT(absTransforms.size() == staticDrawableInfo.size(),
                 ""ResourceManager::computeGeneralMeshAbsoluteAABBs: number of ""
                 ""transforms does not match number of drawables."", );

  for (uint32_t iEntry = 0; iEntry < absTransforms.size(); ++iEntry) {
    const uint32_t meshID = staticDrawableInfo[iEntry].meshID;

    Cr::Containers::Optional<Magnum::Trade::MeshData>& meshData =
        meshes_[meshID]->getMeshData();
    CORRADE_ASSERT(meshData,
                   ""ResourceManager::computeGeneralMeshAbsoluteAABBs: The mesh ""
                   ""data specified at ID:""
                       << meshID << ""is empty/undefined. Aborting"", );

    // a vector to store the min, max pos for the aabb of every position array
    std::vector<Mn::Vector3> bbPos;

    // transform the vertex positions to the world space, compute the aabb for
    // each position array
    for (uint32_t jArray = 0;
         jArray < meshData->attributeCount(Mn::Trade::MeshAttribute::Position);
         ++jArray) {
      Cr::Containers::Array<Mn::Vector3> pos =
          meshData->positions3DAsArray(jArray);
      Mn::MeshTools::transformPointsInPlace(absTransforms[iEntry], pos);

      std::pair<Mn::Vector3, Mn::Vector3> bb = Mn::Math::minmax(pos);
      bbPos.push_back(std::move(bb.first));
      bbPos.push_back(std::move(bb.second));
    }

    // locate the scene node which contains the current drawable
    scene::SceneNode& node = staticDrawableInfo[iEntry].node;

    // set the absolute axis aligned bounding box
    node.setAbsoluteAABB(Mn::Math::minmax(bbPos));

  }  // iEntry
}  // ResourceManager::computeGeneralMeshAbsoluteAABBs

void ResourceManager::computeInstanceMeshAbsoluteAABBs(
    const std::vector<StaticDrawableInfo>& staticDrawableInfo) {
  std::vector<Mn::Matrix4> absTransforms =
      computeAbsoluteTransformations(staticDrawableInfo);

  CORRADE_ASSERT(
      absTransforms.size() == staticDrawableInfo.size(),
      ""ResourceManager::computeInstancelMeshAbsoluteAABBs: Number of ""
      ""transforms does not match number of drawables. Aborting."", );

  for (size_t iEntry = 0; iEntry < absTransforms.size(); ++iEntry) {
    const uint32_t meshID = staticDrawableInfo[iEntry].meshID;

    // convert std::vector<vec3f> to std::vector<Mn::Vector3>
    const std::vector<vec3f>& vertexPositions =
        dynamic_cast<GenericInstanceMeshData&>(*meshes_[meshID])
            .getVertexBufferObjectCPU();
    std::vector<Mn::Vector3> transformedPositions{vertexPositions.begin(),
                                                  vertexPositions.end()};

    Mn::MeshTools::transformPointsInPlace(absTransforms[iEntry],
                                          transformedPositions);

    scene::SceneNode& node = staticDrawableInfo[iEntry].node;
    node.setAbsoluteAABB(Mn::Math::minmax(transformedPositions));
  }  // iEntry
}

std::vector<Mn::Matrix4> ResourceManager::computeAbsoluteTransformations(
    const std::vector<StaticDrawableInfo>& staticDrawableInfo) {
  // sanity check
  if (staticDrawableInfo.size() == 0) {
    return {};
  }

  // basic assumption is that all the drawables are in the same scene;
  // so use the 1st element in the vector to obtain this scene
  auto* scene = dynamic_cast<MagnumScene*>(staticDrawableInfo[0].node.scene());

  CORRADE_ASSERT(scene != nullptr,
                 ""ResourceManager::computeAbsoluteTransformations: The node is ""
                 ""not attached to any scene graph. Aborting."",
                 {});

  // collect all drawable objects
  std::vector<std::reference_wrapper<MagnumObject>> objects;
  objects.reserve(staticDrawableInfo.size());
  std::transform(staticDrawableInfo.begin(), staticDrawableInfo.end(),
                 std::back_inserter(objects),
                 [](const StaticDrawableInfo& info) -> MagnumObject& {
                   return info.node;
                 });

  // compute transformations of all objects in the group relative to the root,
  // which are the absolute transformations
  std::vector<Mn::Matrix4> absTransforms =
      scene->transformationMatrices(objects);

  return absTransforms;
}

void ResourceManager::translateMesh(BaseMesh* meshDataGL,
                                    Magnum::Vector3 translation) {
  CollisionMeshData& meshData = meshDataGL->getCollisionMeshData();

  Magnum::Matrix4 transform = Magnum::Matrix4::translation(translation);
  Magnum::MeshTools::transformPointsInPlace(transform, meshData.positions);
  // save the mesh transformation for future query
  meshDataGL->meshTransform_ = transform * meshDataGL->meshTransform_;

  meshDataGL->BB = meshDataGL->BB.translated(translation);
}

void ResourceManager::buildPrimitiveAssetData(
    const std::string& primTemplateHandle) {
  auto primTemplate =
      assetAttributesManager_->getObjectByHandle(primTemplateHandle);
  // check if unique name of attributes describing primitive asset is present
  // already - don't remake if so
  auto primAssetHandle = primTemplate->getHandle();
  if (resourceDict_.count(primAssetHandle) > 0) {
    LOG(INFO) << "" Primitive Asset exists already : "" << primAssetHandle;
    return;
  }

  // class of primitive object
  std::string primClassName = primTemplate->getPrimObjClassName();
  // make sure it is open before use
  primitiveImporter_->openData("""");
  // configuration for PrimitiveImporter - replace appropriate group's data
  // before instancing prim object
  Cr::Utility::ConfigurationGroup& conf = primitiveImporter_->configuration();
  Cr::Utility::ConfigurationGroup* cfgGroup = conf.group(primClassName);
  if (cfgGroup != nullptr) {  // ignore prims with no configuration like cubes
    auto newCfgGroup = primTemplate->getConfigGroup();
    // replace current conf group with passed attributes
    *cfgGroup = newCfgGroup;
  }

  // make assetInfo
  AssetInfo info{AssetType::PRIMITIVE};
  info.requiresLighting = true;
  // set up primitive mesh
  // make  primitive mesh structure
  auto primMeshData = std::make_unique<GenericMeshData>(false);
  // build mesh data object
  primMeshData->importAndSetMeshData(*primitiveImporter_, primClassName);

  // compute the mesh bounding box
  primMeshData->BB = computeMeshBB(primMeshData.get());

  primMeshData->uploadBuffersToGPU(false);

  // make MeshMetaData
  int meshStart = meshes_.size();
  int meshEnd = meshStart;
  MeshMetaData meshMetaData{meshStart, meshEnd};

  meshes_.emplace_back(std::move(primMeshData));

  // default material for now
  std::unique_ptr<gfx::MaterialData> phongMaterial =
      gfx::PhongMaterialData::create_unique();

  meshMetaData.setMaterialIndices(nextMaterialID_, nextMaterialID_);
  shaderManager_.set(std::to_string(nextMaterialID_++),
                     phongMaterial.release());

  meshMetaData.root.meshIDLocal = 0;
  meshMetaData.root.componentID = 0;
  // store the rotation to world frame upon load - currently superfluous
  const quatf transform = info.frame.rotationFrameToWorld();
  Magnum::Matrix4 R = Magnum::Matrix4::from(
      Magnum::Quaternion(transform).toMatrix(), Magnum::Vector3());
  meshMetaData.root.transformFromLocalToParent =
      R * meshMetaData.root.transformFromLocalToParent;

  // make LoadedAssetData corresponding to this asset
  LoadedAssetData loadedAssetData{info, meshMetaData};
  auto inserted =
      resourceDict_.emplace(primAssetHandle, std::move(loadedAssetData));

  LOG(INFO) << "" Primitive Asset Added : ID : "" << primTemplate->getID()
            << "" : attr lib key : "" << primTemplate->getHandle()
            << "" | instance class : "" << primClassName
            << "" | Conf has group for this obj type : ""
            << conf.hasGroup(primClassName);

}  // buildPrimitiveAssetData

bool ResourceManager::loadPTexMeshData(const AssetInfo& info,
                                       scene::SceneNode* parent,
                                       DrawableGroup* drawables) {
#ifdef ESP_BUILD_PTEX_SUPPORT
  // if this is a new file, load it and add it to the dictionary
  const std::string& filename = info.filepath;
  if (resourceDict_.count(filename) == 0) {
    const auto atlasDir = Cr::Utility::Directory::join(
        Cr::Utility::Directory::path(filename), ""textures"");

    meshes_.emplace_back(std::make_unique<PTexMeshData>());
    int index = meshes_.size() - 1;
    auto* pTexMeshData = dynamic_cast<PTexMeshData*>(meshes_[index].get());
    pTexMeshData->load(filename, atlasDir);

    // update the dictionary
    auto inserted =
        resourceDict_.emplace(filename, LoadedAssetData{info, {index, index}});
    MeshMetaData& meshMetaData = inserted.first->second.meshMetaData;
    meshMetaData.root.meshIDLocal = 0;
    meshMetaData.root.componentID = 0;
    // store the rotation to world frame upon load
    const quatf transform = info.frame.rotationFrameToWorld();
    Magnum::Matrix4 R = Magnum::Matrix4::from(
        Magnum::Quaternion(transform).toMatrix(), Magnum::Vector3());
    meshMetaData.root.transformFromLocalToParent =
        R * meshMetaData.root.transformFromLocalToParent;
  }

  // create the scene graph by request
  if (parent) {
    auto indexPair = getMeshMetaData(filename).meshIndex;
    int start = indexPair.first;
    int end = indexPair.second;
    std::vector<StaticDrawableInfo> staticDrawableInfo;

    for (int iMesh = start; iMesh <= end; ++iMesh) {
      auto* pTexMeshData = dynamic_cast<PTexMeshData*>(meshes_[iMesh].get());

      pTexMeshData->uploadBuffersToGPU(false);

      for (int jSubmesh = 0; jSubmesh < pTexMeshData->getSize(); ++jSubmesh) {
        scene::SceneNode& node = parent->createChild();
        const quatf transform = info.frame.rotationFrameToWorld();
        node.setRotation(Magnum::Quaternion(transform));

        node.addFeature<gfx::PTexMeshDrawable>(*pTexMeshData, jSubmesh,
                                               shaderManager_, drawables);

        staticDrawableInfo.emplace_back(
            StaticDrawableInfo{node, static_cast<uint32_t>(jSubmesh)});
      }
    }
    // always compute absolute aabb for the PTEX mesh if parent exists
    // because the ptex mesh is for sure a static scene.
    CORRADE_ASSERT(
        resourceDict_.count(filename) != 0,
        ""ResourceManager::loadScene: ptex mesh is not loaded. Aborting."",
        false);
    const MeshMetaData& metaData = getMeshMetaData(filename);
    CORRADE_ASSERT(metaData.meshIndex.first == metaData.meshIndex.second,
                   ""ResourceManager::loadScene: ptex mesh is not loaded ""
                   ""correctly. Aborting."",
                   false);

    computePTexMeshAbsoluteAABBs(*meshes_[metaData.meshIndex.first],
                                 staticDrawableInfo);
  }  // if parent

  return true;
#else
  LOG(ERROR) << ""PTex support not enabled. Enable the BUILD_PTEX_SUPPORT CMake ""
                ""option when building."";
  return false;
#endif
}

// semantic instance mesh import
bool ResourceManager::loadInstanceMeshData(
    const AssetInfo& info,
    scene::SceneNode* parent,
    DrawableGroup* drawables,
    bool computeAbsoluteAABBs,
    bool splitSemanticMesh /* = true */) {
  if (info.type != AssetType::INSTANCE_MESH) {
    LOG(ERROR) << ""loadInstanceMeshData only works with INSTANCE_MESH type!"";
    return false;
  }

  Cr::Containers::Pointer<Importer> importer;
  CORRADE_INTERNAL_ASSERT_OUTPUT(
      importer = importerManager_.loadAndInstantiate(""StanfordImporter""));

  // if this is a new file, load it and add it to the dictionary, create
  // shaders and add it to the shaderPrograms_
  const std::string& filename = info.filepath;
  if (resourceDict_.count(filename) == 0) {
    std::vector<GenericInstanceMeshData::uptr> instanceMeshes;
    if (splitSemanticMesh) {
      instanceMeshes =
          GenericInstanceMeshData::fromPlySplitByObjectId(*importer, filename);
    } else {
      GenericInstanceMeshData::uptr meshData =
          GenericInstanceMeshData::fromPLY(*importer, filename);
      if (meshData)
        instanceMeshes.emplace_back(std::move(meshData));
    }

    if (instanceMeshes.empty()) {
      LOG(ERROR) << ""Error loading instance mesh data"";
      return false;
    }

    int meshStart = meshes_.size();
    int meshEnd = meshStart + instanceMeshes.size() - 1;
    MeshMetaData meshMetaData{meshStart, meshEnd};
    meshMetaData.root.children.resize(instanceMeshes.size());

    for (int meshIDLocal = 0; meshIDLocal < instanceMeshes.size();
         ++meshIDLocal) {
      instanceMeshes[meshIDLocal]->uploadBuffersToGPU(false);
      meshes_.emplace_back(std::move(instanceMeshes[meshIDLocal]));

      meshMetaData.root.children[meshIDLocal].meshIDLocal = meshIDLocal;
    }

    // update the dictionary
    resourceDict_.emplace(filename,
                          LoadedAssetData{info, std::move(meshMetaData)});
  }

  // create the scene graph by request
  if (parent) {
    std::vector<StaticDrawableInfo> staticDrawableInfo;
    auto indexPair = getMeshMetaData(filename).meshIndex;
    int start = indexPair.first;
    int end = indexPair.second;

    for (uint32_t iMesh = start; iMesh <= end; ++iMesh) {
      scene::SceneNode& node = parent->createChild();
      node.addFeature<gfx::GenericDrawable>(
          *meshes_[iMesh]->getMagnumGLMesh(), shaderManager_, NO_LIGHT_KEY,
          PER_VERTEX_OBJECT_ID_MATERIAL_KEY, drawables);

      if (computeAbsoluteAABBs) {
        staticDrawableInfo.emplace_back(StaticDrawableInfo{node, iMesh});
      }
    }
    // compute aabb if splitSemanticMesh set here - always done if parent not
    // null and splitSemanticMesh is set to true
    if (computeAbsoluteAABBs) {
      computeInstanceMeshAbsoluteAABBs(staticDrawableInfo);
    }
  }  // if parent not null

  return true;
}

bool ResourceManager::loadGeneralMeshData(
    const AssetInfo& info,
    scene::SceneNode* parent /* = nullptr */,
    DrawableGroup* drawables /* = nullptr */,
    bool computeAbsoluteAABBs, /* = false */
    const Mn::ResourceKey& lightSetup) {
  const std::string& filename = info.filepath;
  const bool fileIsLoaded = resourceDict_.count(filename) > 0;
  const bool drawData = parent != nullptr && drawables != nullptr;

  // Preferred plugins, Basis target GPU format
  importerManager_.setPreferredPlugins(""GltfImporter"", {""TinyGltfImporter""});
#ifdef ESP_BUILD_ASSIMP_SUPPORT
  importerManager_.setPreferredPlugins(""ObjImporter"", {""AssimpImporter""});
#endif
  {
    Cr::PluginManager::PluginMetadata* const metadata =
        importerManager_.metadata(""BasisImporter"");
    Mn::GL::Context& context = Mn::GL::Context::current();
#ifdef MAGNUM_TARGET_WEBGL
    if (context.isExtensionSupported<
            Mn::GL::Extensions::WEBGL::compressed_texture_astc>())
#else
    if (context.isExtensionSupported<
            Mn::GL::Extensions::KHR::texture_compression_astc_ldr>())
#endif
    {
      LOG(INFO) << ""Importing Basis files as ASTC 4x4"";
      metadata->configuration().setValue(""format"", ""Astc4x4RGBA"");
    }
#ifdef MAGNUM_TARGET_GLES
    else if (context.isExtensionSupported<
                 Mn::GL::Extensions::EXT::texture_compression_bptc>())
#else
    else if (context.isExtensionSupported<
                 Mn::GL::Extensions::ARB::texture_compression_bptc>())
#endif
    {
      LOG(INFO) << ""Importing Basis files as BC7"";
      metadata->configuration().setValue(""format"", ""Bc7RGBA"");
    }
#ifdef MAGNUM_TARGET_WEBGL
    else if (context.isExtensionSupported<
                 Mn::GL::Extensions::WEBGL::compressed_texture_s3tc>())
#elif defined(MAGNUM_TARGET_GLES)
    else if (context.isExtensionSupported<
                 Mn::GL::Extensions::EXT::texture_compression_s3tc>() ||
             context.isExtensionSupported<
                 Mn::GL::Extensions::ANGLE::texture_compression_dxt5>())
#else
    else if (context.isExtensionSupported<
                 Mn::GL::Extensions::EXT::texture_compression_s3tc>())
#endif
    {
      LOG(INFO) << ""Importing Basis files as BC3"";
      metadata->configuration().setValue(""format"", ""Bc3RGBA"");
    }
#ifndef MAGNUM_TARGET_GLES2
    else
#ifndef MAGNUM_TARGET_GLES
        if (context.isExtensionSupported<
                Mn::GL::Extensions::ARB::ES3_compatibility>())
#endif
    {
      LOG(INFO) << ""Importing Basis files as ETC2"";
      metadata->configuration().setValue(""format"", ""Etc2RGBA"");
    }
#else /* For ES2, fall back to PVRTC as ETC2 is not available */
    else
#ifdef MAGNUM_TARGET_WEBGL
        if (context.isExtensionSupported<Mn::WEBGL::compressed_texture_pvrtc>())
#else
        if (context.isExtensionSupported<Mn::IMG::texture_compression_pvrtc>())
#endif
    {
      LOG(INFO) << ""Importing Basis files as PVRTC 4bpp"";
      metadata->configuration().setValue(""format"", ""PvrtcRGBA4bpp"");
    }
#endif
#if defined(MAGNUM_TARGET_GLES2) || !defined(MAGNUM_TARGET_GLES)
    else /* ES3 has ETC2 always */
    {
      LOG(WARNING) << ""No supported GPU compressed texture format detected, ""
                      ""Basis images will get imported as RGBA8"";
      metadata->configuration().setValue(""format"", ""RGBA8"");
    }
#endif
  }

  // Optional File loading
  if (!fileIsLoaded) {
    if (!fileImporter_->openFile(filename)) {
      LOG(ERROR) << ""Cannot open file "" << filename;
      return false;
    }

    // if this is a new file, load it and add it to the dictionary
    LoadedAssetData loadedAssetData{info};
    if (requiresTextures_) {
      loadTextures(*fileImporter_, loadedAssetData);
      loadMaterials(*fileImporter_, loadedAssetData);
    }
    loadMeshes(*fileImporter_, loadedAssetData);
    auto inserted = resourceDict_.emplace(filename, std::move(loadedAssetData));
    MeshMetaData& meshMetaData = inserted.first->second.meshMetaData;

    // Register magnum mesh
    if (fileImporter_->defaultScene() != -1) {
      Cr::Containers::Optional<Magnum::Trade::SceneData> sceneData =
          fileImporter_->scene(fileImporter_->defaultScene());
      if (!sceneData) {
        LOG(ERROR) << ""Cannot load scene, exiting"";
        return false;
      }
      for (unsigned int sceneDataID : sceneData->children3D()) {
        loadMeshHierarchy(*fileImporter_, meshMetaData.root, sceneDataID);
      }
    } else if (fileImporter_->meshCount() &&
               meshes_[meshMetaData.meshIndex.first]) {
      // no default scene --- standalone OBJ/PLY files, for example
      // take a wild guess and load the first mesh with the first material
      // addMeshToDrawables(metaData, *parent, drawables, 0, 0);
      loadMeshHierarchy(*fileImporter_, meshMetaData.root, 0);
    } else {
      LOG(ERROR) << ""No default scene available and no meshes found, exiting"";
      return false;
    }

    const quatf transform = info.frame.rotationFrameToWorld();
    Magnum::Matrix4 R = Magnum::Matrix4::from(
        Magnum::Quaternion(transform).toMatrix(), Magnum::Vector3());
    meshMetaData.root.transformFromLocalToParent =
        R * meshMetaData.root.transformFromLocalToParent;
  } else if (resourceDict_[filename].assetInfo != info) {
    // Right now, we only allow for an asset to be loaded with one
    // configuration, since generated mesh data may be invalid for a new
    // configuration
    LOG(ERROR) << ""Reloading asset "" << filename
               << "" with different configuration not currently supported. ""
               << ""Asset may not be rendered correctly."";
  }

  // Optional Instantiation
  if (!drawData) {
    //! Do not instantiate object
    return true;
  }
  // parent != nullptr to reach here

  //! Do instantiate object
  const LoadedAssetData& loadedAssetData = resourceDict_[filename];
  if (!isLightSetupCompatible(loadedAssetData, lightSetup)) {
    LOG(WARNING) << ""Loading scene with incompatible light setup, ""
                    ""scene will not be correctly lit. If the scene requires ""
                    ""lighting please enable AssetInfo::requiresLighting."";
  }
  const MeshMetaData& meshMetaData = loadedAssetData.meshMetaData;

  scene::SceneNode& newNode = parent->createChild();
  const bool forceReload = false;
  // re-bind position, normals, uv, colors etc. to the corresponding buffers
  // under *current* gl context
  if (forceReload) {
    int start = meshMetaData.meshIndex.first;
    int end = meshMetaData.meshIndex.second;
    if (0 <= start && start <= end) {
      for (int iMesh = start; iMesh <= end; ++iMesh) {
        meshes_[iMesh]->uploadBuffersToGPU(forceReload);
      }
    }
  }  // forceReload
     // TODO: cache visual nodes added by this process
  std::vector<scene::SceneNode*> visNodeCache;
  std::vector<StaticDrawableInfo> staticDrawableInfo;
  addComponent(meshMetaData, newNode, lightSetup, drawables, meshMetaData.root,
               visNodeCache, computeAbsoluteAABBs, staticDrawableInfo);
  if (computeAbsoluteAABBs) {
    // now compute aabbs by constructed staticDrawableInfo
    computeGeneralMeshAbsoluteAABBs(staticDrawableInfo);
  }

  return true;
}  // loadGeneralMeshData

int ResourceManager::loadNavMeshVisualization(esp::nav::PathFinder& pathFinder,
                                              scene::SceneNode* parent,
                                              DrawableGroup* drawables) {
  int navMeshPrimitiveID = ID_UNDEFINED;

  if (!pathFinder.isLoaded())
    return navMeshPrimitiveID;

  // create the mesh
  std::vector<Magnum::UnsignedInt> indices;
  std::vector<Magnum::Vector3> positions;

  const MeshData::ptr navMeshData = pathFinder.getNavMeshData();

  // add the vertices
  positions.resize(navMeshData->vbo.size());
  for (size_t vix = 0; vix < navMeshData->vbo.size(); vix++) {
    positions[vix] = Magnum::Vector3{navMeshData->vbo[vix]};
  }

  indices.resize(navMeshData->ibo.size() * 2);
  for (size_t ix = 0; ix < navMeshData->ibo.size();
       ix += 3) {  // for each triangle, create lines
    size_t nix = ix * 2;
    indices[nix] = navMeshData->ibo[ix];
    indices[nix + 1] = navMeshData->ibo[ix + 1];
    indices[nix + 2] = navMeshData->ibo[ix + 1];
    indices[nix + 3] = navMeshData->ibo[ix + 2];
    indices[nix + 4] = navMeshData->ibo[ix + 2];
    indices[nix + 5] = navMeshData->ibo[ix];
  }

  // create a temporary mesh object referencing the above data
  Mn::Trade::MeshData visualNavMesh{
      Mn::MeshPrimitive::Lines,
      {},
      indices,
      Mn::Trade::MeshIndexData{indices},
      {},
      positions,
      {Mn::Trade::MeshAttributeData{Mn::Trade::MeshAttribute::Position,
                                    Cr::Containers::arrayView(positions)}}};

  // compile and add the new mesh to the structure
  primitive_meshes_[nextPrimitiveMeshId++] = std::make_unique<Magnum::GL::Mesh>(
      Magnum::MeshTools::compile(visualNavMesh));

  navMeshPrimitiveID = nextPrimitiveMeshId - 1;

  if (parent != nullptr && drawables != nullptr &&
      navMeshPrimitiveID != ID_UNDEFINED) {
    // create the drawable
    addPrimitiveToDrawables(navMeshPrimitiveID, *parent, drawables);
  }

  return navMeshPrimitiveID;
}  // loadNavMeshVisualization

void ResourceManager::loadMaterials(Importer& importer,
                                    LoadedAssetData& loadedAssetData) {
  int materialStart = nextMaterialID_;
  int materialEnd = materialStart + importer.materialCount() - 1;
  loadedAssetData.meshMetaData.setMaterialIndices(materialStart, materialEnd);

  for (int iMaterial = 0; iMaterial < importer.materialCount(); ++iMaterial) {
    int currentMaterialID = nextMaterialID_++;

    // TODO:
    // it seems we have a way to just load the material once in this case,
    // as long as the materialName includes the full path to the material
    Cr::Containers::Optional<Mn::Trade::MaterialData> materialData =
        importer.material(iMaterial);

    if (!materialData) {
      LOG(ERROR) << ""Cannot load material, skipping"";
      continue;
    }

    std::unique_ptr<gfx::MaterialData> finalMaterial;
    int textureBaseIndex = loadedAssetData.meshMetaData.textureIndex.first;

    if (loadedAssetData.assetInfo.requiresLighting &&
        materialData->types() &
            Magnum::Trade::MaterialType::PbrMetallicRoughness) {
      const Mn::Trade::PbrMetallicRoughnessMaterialData&
          pbrMetallicRoughnessMaterialData =
              static_cast<Mn::Trade::PbrMetallicRoughnessMaterialData&>(
                  *materialData);

      finalMaterial = gfx::buildPhongFromPbrMetallicRoughness(
          pbrMetallicRoughnessMaterialData, textureBaseIndex, textures_);
    } else {
      ASSERT(materialData);
      if (!(materialData->types() & Magnum::Trade::MaterialType::Phong)) {
        LOG(ERROR) << ""Cannot load material, skipping"";
        continue;
      }

      const auto& phongMaterialData =
          materialData->as<Mn::Trade::PhongMaterialData>();
      if (loadedAssetData.assetInfo.requiresLighting) {
        finalMaterial =
            buildPhongShadedMaterialData(phongMaterialData, textureBaseIndex);

      } else {
        finalMaterial =
            buildFlatShadedMaterialData(phongMaterialData, textureBaseIndex);
      }
    }
    // for now, just use unique ID for material key. This may change if we
    // expose materials to user for post-load modification
    shaderManager_.set(std::to_string(currentMaterialID),
                       finalMaterial.release());
  }
}

gfx::PhongMaterialData::uptr ResourceManager::buildFlatShadedMaterialData(
    const Mn::Trade::PhongMaterialData& material,
    int textureBaseIndex) {
  // NOLINTNEXTLINE(google-build-using-namespace)
  using namespace Mn::Math::Literals;

  auto finalMaterial = gfx::PhongMaterialData::create_unique();
  finalMaterial->ambientColor = 0xffffffff_rgbaf;
  finalMaterial->diffuseColor = 0x00000000_rgbaf;
  finalMaterial->specularColor = 0x00000000_rgbaf;

  if (material.hasAttribute(Mn::Trade::MaterialAttribute::AmbientTexture)) {
    finalMaterial->ambientTexture =
        textures_[textureBaseIndex + material.ambientTexture()].get();
  } else if (material.hasAttribute(
                 Mn::Trade::MaterialAttribute::DiffuseTexture)) {
    // if we want to force flat shading, but we don't have ambient texture,
    // check for diffuse texture and use that instead
    finalMaterial->ambientTexture =
        textures_[textureBaseIndex + material.diffuseTexture()].get();
  } else {
    finalMaterial->ambientColor = material.ambientColor();
  }
  return finalMaterial;
}

gfx::PhongMaterialData::uptr ResourceManager::buildPhongShadedMaterialData(
    const Mn::Trade::PhongMaterialData& material,
    int textureBaseIndex) {
  // NOLINTNEXTLINE(google-build-using-namespace)
  using namespace Mn::Math::Literals;

  auto finalMaterial = gfx::PhongMaterialData::create_unique();
  finalMaterial->shininess = material.shininess();

  // texture transform, if there's none the matrix is an identity
  finalMaterial->textureMatrix = material.commonTextureMatrix();

  // ambient material properties
  finalMaterial->ambientColor = material.ambientColor();
  if (material.hasAttribute(Mn::Trade::MaterialAttribute::AmbientTexture)) {
    finalMaterial->ambientTexture =
        textures_[textureBaseIndex + material.ambientTexture()].get();
  }

  // diffuse material properties
  finalMaterial->diffuseColor = material.diffuseColor();
  if (material.hasAttribute(Mn::Trade::MaterialAttribute::DiffuseTexture)) {
    finalMaterial->diffuseTexture =
        textures_[textureBaseIndex + material.diffuseTexture()].get();
  }

  // specular material properties
  finalMaterial->specularColor = material.specularColor();
  if (material.hasSpecularTexture()) {
    finalMaterial->specularTexture =
        textures_[textureBaseIndex + material.specularTexture()].get();
  }

  // normal mapping
  if (material.hasAttribute(Mn::Trade::MaterialAttribute::NormalTexture)) {
    finalMaterial->normalTexture =
        textures_[textureBaseIndex + material.normalTexture()].get();
  }
  return finalMaterial;
}

void ResourceManager::loadMeshes(Importer& importer,
                                 LoadedAssetData& loadedAssetData) {
  int meshStart = meshes_.size();
  int meshEnd = meshStart + importer.meshCount() - 1;
  loadedAssetData.meshMetaData.setMeshIndices(meshStart, meshEnd);

  for (int iMesh = 0; iMesh < importer.meshCount(); ++iMesh) {
    // don't need normals if we aren't using lighting
    auto gltfMeshData = std::make_unique<GenericMeshData>(
        loadedAssetData.assetInfo.requiresLighting);
    gltfMeshData->importAndSetMeshData(importer, iMesh);

    // compute the mesh bounding box
    gltfMeshData->BB = computeMeshBB(gltfMeshData.get());

    gltfMeshData->uploadBuffersToGPU(false);
    meshes_.emplace_back(std::move(gltfMeshData));
  }
}

//! Recursively load the transformation chain specified by the mesh file
void ResourceManager::loadMeshHierarchy(Importer& importer,
                                        MeshTransformNode& parent,
                                        int componentID) {
  std::unique_ptr<Magnum::Trade::ObjectData3D> objectData =
      importer.object3D(componentID);
  if (!objectData) {
    LOG(ERROR) << ""Cannot import object "" << importer.object3DName(componentID)
               << "", skipping"";
    return;
  }

  // Add the new node to the hierarchy and set its transformation
  parent.children.push_back(MeshTransformNode());
  parent.children.back().transformFromLocalToParent =
      objectData->transformation();
  parent.children.back().componentID = componentID;

  const int meshIDLocal = objectData->instance();

  // Add a mesh index
  if (objectData->instanceType() == Magnum::Trade::ObjectInstanceType3D::Mesh &&
      meshIDLocal != ID_UNDEFINED) {
    parent.children.back().meshIDLocal = meshIDLocal;
    if (requiresTextures_) {
      parent.children.back().materialIDLocal =
          static_cast<Magnum::Trade::MeshObjectData3D*>(objectData.get())
              ->material();
    } else {
      parent.children.back().materialIDLocal = ID_UNDEFINED;
    }
  }

  // Recursively add children
  for (auto childObjectID : objectData->children()) {
    loadMeshHierarchy(importer, parent.children.back(), childObjectID);
  }
}

void ResourceManager::loadTextures(Importer& importer,
                                   LoadedAssetData& loadedAssetData) {
  int textureStart = textures_.size();
  int textureEnd = textureStart + importer.textureCount() - 1;
  loadedAssetData.meshMetaData.setTextureIndices(textureStart, textureEnd);

  for (int iTexture = 0; iTexture < importer.textureCount(); ++iTexture) {
    textures_.emplace_back(std::make_shared<Magnum::GL::Texture2D>());
    auto& currentTexture = textures_.back();

    auto textureData = importer.texture(iTexture);
    if (!textureData ||
        textureData->type() != Magnum::Trade::TextureData::Type::Texture2D) {
      LOG(ERROR) << ""Cannot load texture "" << iTexture << "" skipping"";
      currentTexture = nullptr;
      continue;
    }

    // Configure the texture
    Mn::GL::Texture2D& texture = *(textures_[textureStart + iTexture].get());
    texture.setMagnificationFilter(textureData->magnificationFilter())
        .setMinificationFilter(textureData->minificationFilter(),
                               textureData->mipmapFilter())
        .setWrapping(textureData->wrapping().xy());

    // Load all mip levels
    const std::uint32_t levelCount =
        importer.image2DLevelCount(textureData->image());
    bool generateMipmap = false;
    for (std::uint32_t level = 0; level != levelCount; ++level) {
      // TODO:
      // it seems we have a way to just load the image once in this case,
      // as long as the image2DName include the full path to the image
      Cr::Containers::Optional<Mn::Trade::ImageData2D> image =
          importer.image2D(textureData->image(), level);
      if (!image) {
        LOG(ERROR) << ""Cannot load texture image, skipping"";
        currentTexture = nullptr;
        break;
      }

      Mn::GL::TextureFormat format;
      if (image->isCompressed()) {
        format = Mn::GL::textureFormat(image->compressedFormat());
      } else {
        format = Mn::GL::textureFormat(image->format());
      }

      // For the very first level, allocate the texture
      if (level == 0) {
        // If there is just one level and the image is not compressed, we'll
        // generate mips ourselves
        if (levelCount == 1 && !image->isCompressed()) {
          texture.setStorage(Mn::Math::log2(image->size().max()) + 1, format,
                             image->size());
          generateMipmap = true;
        } else
          texture.setStorage(levelCount, format, image->size());
      }

      if (image->isCompressed())
        texture.setCompressedSubImage(level, {}, *image);
      else
        texture.setSubImage(level, {}, *image);
    }

    // Mip level loading failed, fail the whole texture
    if (currentTexture == nullptr)
      continue;

    // Generate a mipmap if requested
    if (generateMipmap)
      texture.generateMipmap();
  }
}  // ResourceManager::loadTextures

bool ResourceManager::instantiateAssetsOnDemand(
    const std::string& objectTemplateHandle) {
  // Meta data
  ObjectAttributes::ptr ObjectAttributes =
      objectAttributesManager_->getObjectByHandle(objectTemplateHandle);

  // if attributes are ""dirty"" (important values have changed since last
  // registered) then re-register.  Should never return ID_UNDEFINED - this
  // would mean something has corrupted the library.
  // NOTE : this is called when an new object is being made, but before the
  // object has acquired a copy of its parent attributes.  No object should
  // ever have a copy of attributes with isDirty == true - any editing of
  // attributes for objects requires object rebuilding.
  if (ObjectAttributes->getIsDirty()) {
    CORRADE_ASSERT(
        (ID_UNDEFINED != objectAttributesManager_->registerObject(
                             ObjectAttributes, objectTemplateHandle)),
        ""ResourceManager::instantiateAssetsOnDemand : Unknown failure ""
        ""attempting to register modified template :""
            << objectTemplateHandle
            << ""before asset instantiation.  Aborting. "",
        false);
  }

  // get render asset handle
  std::string renderAssetHandle = ObjectAttributes->getRenderAssetHandle();
  // whether attributes requires lighting
  bool requiresLighting = ObjectAttributes->getRequiresLighting();
  bool renderMeshSuccess = false;
  // no resource dict entry exists for renderAssetHandle
  if (resourceDict_.count(renderAssetHandle) == 0) {
    if (ObjectAttributes->getRenderAssetIsPrimitive()) {
      // needs to have a primitive asset attributes with same name
      if (!assetAttributesManager_->getObjectLibHasHandle(renderAssetHandle)) {
        // this is bad, means no render primitive template exists with
        // expected name.  should never happen
        LOG(ERROR) << ""No primitive asset attributes exists with name :""
                   << renderAssetHandle
                   << "" so unable to instantiate primitive-based render ""
                      ""object.  Aborting."";
        return false;
      }
      // build primitive asset for this object based on defined primitive
      // attributes
      buildPrimitiveAssetData(renderAssetHandle);

    } else {
      // load/check_for render mesh metadata and load assets
      renderMeshSuccess = loadObjectMeshDataFromFile(
          renderAssetHandle, objectTemplateHandle, ""render"", requiresLighting);
    }
  }  // if no render asset exists

  // check if uses collision mesh
  if (!ObjectAttributes->getCollisionAssetIsPrimitive()) {
    const auto collisionAssetHandle =
        ObjectAttributes->getCollisionAssetHandle();
    if (resourceDict_.count(collisionAssetHandle) == 0) {
      bool collisionMeshSuccess = loadObjectMeshDataFromFile(
          collisionAssetHandle, objectTemplateHandle, ""collision"",
          !renderMeshSuccess && requiresLighting);

      if (!collisionMeshSuccess) {
        return false;
      }
    }
    // check if collision handle exists in collision mesh groups yet.  if not
    // then instance
    if (collisionMeshGroups_.count(collisionAssetHandle) == 0) {
      // set collision mesh data
      const MeshMetaData& meshMetaData = getMeshMetaData(collisionAssetHandle);

      int start = meshMetaData.meshIndex.first;
      int end = meshMetaData.meshIndex.second;
      //! Gather mesh components for meshGroup data
      std::vector<CollisionMeshData> meshGroup;
      for (int mesh_i = start; mesh_i <= end; ++mesh_i) {
        GenericMeshData& gltfMeshData =
            dynamic_cast<GenericMeshData&>(*meshes_[mesh_i].get());
        CollisionMeshData& meshData = gltfMeshData.getCollisionMeshData();
        meshGroup.push_back(meshData);
      }
      collisionMeshGroups_.emplace(collisionAssetHandle, meshGroup);
    }
  }

  return true;
}  // ResourceManager::instantiateAssetsOnDemand

void ResourceManager::addObjectToDrawables(
    const std::string& objTemplateHandle,
    scene::SceneNode* parent,
    DrawableGroup* drawables,
    std::vector<scene::SceneNode*>& visNodeCache,
    const Mn::ResourceKey& lightSetup) {
  if (parent != nullptr and drawables != nullptr) {
    //! Add mesh to rendering stack

    // Meta data
    ObjectAttributes::ptr ObjectAttributes =
        objectAttributesManager_->getObjectByHandle(objTemplateHandle);

    const std::string& renderObjectName =
        ObjectAttributes->getRenderAssetHandle();

    const LoadedAssetData& loadedAssetData = resourceDict_.at(renderObjectName);
    if (!isLightSetupCompatible(loadedAssetData, lightSetup)) {
      LOG(WARNING) << ""Instantiating object with incompatible light setup, ""
                      ""object will not be correctly lit. If you need lighting ""
                      ""please ensure 'requires lighting' is enabled in object ""
                      ""config file"";
    }

    // need a new node for scaling because motion state will override scale
    // set at the physical node
    scene::SceneNode& scalingNode = parent->createChild();
    visNodeCache.push_back(&scalingNode);
    Magnum::Vector3 objectScaling = ObjectAttributes->getScale();
    scalingNode.setScaling(objectScaling);
    // ignored for objects since computeAbsoluteAABBs is always set to false
    // after scene is loaded.
    std::vector<StaticDrawableInfo> staticDrawableInfo;

    addComponent(loadedAssetData.meshMetaData, scalingNode, lightSetup,
                 drawables, loadedAssetData.meshMetaData.root, visNodeCache,
                 false, staticDrawableInfo);

    // set the node type for all cached visual nodes
    for (auto node : visNodeCache) {
      node->setType(scene::SceneNodeType::OBJECT);
    }
  }  // should always be specified, otherwise won't do anything
}  // addObjectToDrawables

//! Add component to rendering stack, based on importer loading
void ResourceManager::addComponent(
    const MeshMetaData& metaData,
    scene::SceneNode& parent,
    const Mn::ResourceKey& lightSetup,
    DrawableGroup* drawables,
    const MeshTransformNode& meshTransformNode,
    std::vector<scene::SceneNode*>& visNodeCache,
    bool computeAbsoluteAABBs,
    std::vector<StaticDrawableInfo>& staticDrawableInfo) {
  // Add the object to the scene and set its transformation
  scene::SceneNode& node = parent.createChild();
  visNodeCache.push_back(&node);
  node.MagnumObject::setTransformation(
      meshTransformNode.transformFromLocalToParent);

  const int meshIDLocal = meshTransformNode.meshIDLocal;

  // Add a drawable if the object has a mesh and the mesh is loaded
  if (meshIDLocal != ID_UNDEFINED) {
    const int materialIDLocal = meshTransformNode.materialIDLocal;
    const uint32_t meshID = metaData.meshIndex.first + meshIDLocal;
    Magnum::GL::Mesh& mesh = *meshes_[meshID]->getMagnumGLMesh();
    Mn::ResourceKey materialKey;
    if (materialIDLocal == ID_UNDEFINED ||
        metaData.materialIndex.second == ID_UNDEFINED) {
      materialKey = DEFAULT_MATERIAL_KEY;
    } else {
      materialKey =
          std::to_string(metaData.materialIndex.first + materialIDLocal);
    }

    createGenericDrawable(mesh, node, lightSetup, materialKey, drawables);

    // compute the bounding box for the mesh we are adding
    if (computeAbsoluteAABBs) {
      staticDrawableInfo.emplace_back(StaticDrawableInfo{node, meshID});
    }
    BaseMesh* meshBB = meshes_[meshID].get();
    node.setMeshBB(computeMeshBB(meshBB));
  }

  // Recursively add children
  for (auto& child : meshTransformNode.children) {
    addComponent(metaData, node, lightSetup, drawables, child, visNodeCache,
                 computeAbsoluteAABBs, staticDrawableInfo);
  }
}  // addComponent

void ResourceManager::addPrimitiveToDrawables(int primitiveID,
                                              scene::SceneNode& node,
                                              DrawableGroup* drawables) {
  CHECK(primitive_meshes_.count(primitiveID));
  createGenericDrawable(*primitive_meshes_.at(primitiveID), node, NO_LIGHT_KEY,
                        WHITE_MATERIAL_KEY, drawables);
}

void ResourceManager::removePrimitiveMesh(int primitiveID) {
  CHECK(primitive_meshes_.count(primitiveID));
  primitive_meshes_.erase(primitiveID);
}

void ResourceManager::createGenericDrawable(
    Mn::GL::Mesh& mesh,
    scene::SceneNode& node,
    const Mn::ResourceKey& lightSetup,
    const Mn::ResourceKey& material,
    DrawableGroup* group /* = nullptr */) {
  node.addFeature<gfx::GenericDrawable>(mesh, shaderManager_, lightSetup,
                                        material, group);
}

bool ResourceManager::loadSUNCGHouseFile(const AssetInfo& houseInfo,
                                         scene::SceneNode* parent,
                                         DrawableGroup* drawables) {
  ASSERT(parent != nullptr);
  std::string houseFile = Cr::Utility::Directory::join(
      Cr::Utility::Directory::current(), houseInfo.filepath);
  const auto& json = io::parseJsonFile(houseFile);
  const auto& levels = json[""levels""].GetArray();
  std::vector<std::string> pathTokens = io::tokenize(houseFile, ""/"", 0, true);
  ASSERT(pathTokens.size() >= 3);
  pathTokens.pop_back();  // house.json
  const std::string houseId = pathTokens.back();
  pathTokens.pop_back();  // <houseId>
  pathTokens.pop_back();  // house
  const std::string basePath = Cr::Utility::String::join(pathTokens, '/');

  // store nodeIds to obtain linearized index for semantic masks
  std::vector<std::string> nodeIds;

  for (const auto& level : levels) {
    const auto& nodes = level[""nodes""].GetArray();
    for (const auto& node : nodes) {
      const std::string nodeId = node[""id""].GetString();
      const std::string nodeType = node[""type""].GetString();
      const int valid = node[""valid""].GetInt();
      if (valid == 0) {
        continue;
      }

      // helper for creating object nodes
      auto createObjectFunc = [&](const AssetInfo& info,
                                  const std::string& id) -> scene::SceneNode& {
        scene::SceneNode& objectNode = parent->createChild();
        const int nodeIndex = nodeIds.size();
        nodeIds.push_back(id);
        objectNode.setId(nodeIndex);
        if (info.type == AssetType::SUNCG_OBJECT) {
          loadGeneralMeshData(info, &objectNode, drawables);
        }
        return objectNode;
      };

      const std::string roomPath = basePath + ""/room/"" + houseId + ""/"";
      if (nodeType == ""Room"") {
        const std::string roomBase = roomPath + node[""modelId""].GetString();
        const int hideCeiling = node[""hideCeiling""].GetInt();
        const int hideFloor = node[""hideFloor""].GetInt();
        const int hideWalls = node[""hideWalls""].GetInt();
        if (hideCeiling != 1) {
          createObjectFunc({AssetType::SUNCG_OBJECT, roomBase + ""c.glb""},
                           nodeId + ""c"");
        }
        if (hideWalls != 1) {
          createObjectFunc({AssetType::SUNCG_OBJECT, roomBase + ""w.glb""},
                           nodeId + ""w"");
        }
        if (hideFloor != 1) {
          createObjectFunc({AssetType::SUNCG_OBJECT, roomBase + ""f.glb""},
                           nodeId + ""f"");
        }
      } else if (nodeType == ""Object"") {
        const std::string modelId = node[""modelId""].GetString();
        // Parse model-to-scene transformation matrix
        // NOTE: only ""Object"" nodes have transform, other nodes are directly
        // specified in scene coordinates
        std::vector<float> transformVec;
        io::toFloatVector(node[""transform""], &transformVec);
        mat4f transform(transformVec.data());
        const AssetInfo info{
            AssetType::SUNCG_OBJECT,
            basePath + ""/object/"" + modelId + ""/"" + modelId + "".glb""};
        createObjectFunc(info, nodeId)
            .setTransformation(Magnum::Matrix4{transform});
      } else if (nodeType == ""Box"") {
        // TODO(MS): create Box geometry
        createObjectFunc({}, nodeId);
      } else if (nodeType == ""Ground"") {
        const std::string roomBase = roomPath + node[""modelId""].GetString();
        const AssetInfo info{AssetType::SUNCG_OBJECT, roomBase + ""f.glb""};
        createObjectFunc(info, nodeId);
      } else {
        LOG(ERROR) << ""Unrecognized SUNCG house node type "" << nodeType;
      }
    }
  }
  return true;
}
void ResourceManager::initDefaultLightSetups() {
  shaderManager_.set(NO_LIGHT_KEY, gfx::LightSetup{});
  shaderManager_.setFallback(gfx::LightSetup{});
}

void ResourceManager::initDefaultMaterials() {
  shaderManager_.set<gfx::MaterialData>(DEFAULT_MATERIAL_KEY,
                                        new gfx::PhongMaterialData{});
  auto whiteMaterialData = new gfx::PhongMaterialData;
  whiteMaterialData->ambientColor = Magnum::Color4{1.0};
  shaderManager_.set<gfx::MaterialData>(WHITE_MATERIAL_KEY, whiteMaterialData);
  auto perVertexObjectId = new gfx::PhongMaterialData{};
  perVertexObjectId->perVertexObjectId = true;
  perVertexObjectId->vertexColored = true;
  perVertexObjectId->ambientColor = Mn::Color4{1.0};
  shaderManager_.set<gfx::MaterialData>(PER_VERTEX_OBJECT_ID_MATERIAL_KEY,
                                        perVertexObjectId);
  shaderManager_.setFallback<gfx::MaterialData>(new gfx::PhongMaterialData{});
}

bool ResourceManager::isLightSetupCompatible(
    const LoadedAssetData& loadedAssetData,
    const Magnum::ResourceKey& lightSetup) const {
  // if light setup has lights in it, but asset was loaded in as flat shaded,
  // there may be an error when rendering.
  return lightSetup == Mn::ResourceKey{NO_LIGHT_KEY} ||
         loadedAssetData.assetInfo.requiresLighting;
}

//! recursively join all sub-components of a mesh into a single unified
//! MeshData.
void ResourceManager::joinHeirarchy(
    MeshData& mesh,
    const MeshMetaData& metaData,
    const MeshTransformNode& node,
    const Magnum::Matrix4& transformFromParentToWorld) {
  Magnum::Matrix4 transformFromLocalToWorld =
      transformFromParentToWorld * node.transformFromLocalToParent;

  if (node.meshIDLocal != ID_UNDEFINED) {
    CollisionMeshData& meshData =
        meshes_[node.meshIDLocal + metaData.meshIndex.first]
            ->getCollisionMeshData();
    int lastIndex = mesh.vbo.size();
    for (auto& pos : meshData.positions) {
      mesh.vbo.push_back(Magnum::EigenIntegration::cast<vec3f>(
          transformFromLocalToWorld.transformPoint(pos)));
    }
    for (auto& index : meshData.indices) {
      mesh.ibo.push_back(index + lastIndex);
    }
  }

  for (auto& child : node.children) {
    joinHeirarchy(mesh, metaData, child, transformFromLocalToWorld);
  }
}

std::unique_ptr<MeshData> ResourceManager::createJoinedCollisionMesh(
    const std::string& filename) {
  std::unique_ptr<MeshData> mesh = std::make_unique<MeshData>();

  CHECK(resourceDict_.count(filename) > 0);

  const MeshMetaData& metaData = getMeshMetaData(filename);

  Magnum::Matrix4 identity;
  joinHeirarchy(*mesh, metaData, metaData.root, identity);

  return mesh;
}

}  // namespace assets
}  // namespace esp
",16236,True,2953.1614110246255,median
":toc:

:imagesdir: images

= Monitoring Docker Containers

This chapter will cover different ways to monitor a Docker container.

== Docker CLI

`docker container stats` command displays a live stream of container(s) runtime metrics. The command supports CPU, memory usage, memory limit, and network IO metrics.

. Start a container: `docker container run --name web -d jboss/wildfly:10.1.0.Final`
. Check the container stats using `docker container stats web`. It shows the output as:
+
```
CONTAINER           CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
web                 0.14%               274.9MiB / 1.952GiB   13.75%              828B / 0B           96.7MB / 4.1kB      53
```
+
The output is continually updated. It shows:
+
.. Container name
.. Percent CPU utilization
.. Total memory usage vs amount available to the container
.. Percent memory utilization
.. Network activity
.. Disk activity
.. PIDS??
+
. Check stats for multiple containers
.. Terminate single instance of the container
+
```
docker container stop web
docker container rm web
```
+
.. Create a service with multiple replicas of the container
+
```
docker swarm init
docker service create --name=web jboss/wildfly
```
+
.. Now check the stats again:
+
```
docker stats
```
+
to see the output:
+
```
CONTAINER           CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
1f9d5a1c08a8        0.24%               294.9MiB / 1.952GiB   14.75%              828B / 0B           96.5MB / 4.1kB      115
```
+
Note that the container id is shown instead of container's name in this case.
+
. Scale the service to 3 replicas:
+
```
docker service scale web=3
```
+
. The stats are now shown for all three containers:
+
```
CONTAINER           CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
1f9d5a1c08a8        0.14%               287.8MiB / 1.952GiB   14.40%              1.03kB / 0B         96.5MB / 4.1kB      53
a3395efbb6ff        0.77%               263.4MiB / 1.952GiB   13.18%              578B / 0B           0B / 4.1kB          114
f484ff2f4c12        0.06%               294.8MiB / 1.952GiB   14.75%              578B / 0B           0B / 4.1kB          114
```
+
. Display only container id and percent CPU utilization using the command `docker container stats --format ""{{.Container}}: {{.CPUPerc}}""`:
+
```
55198043b6aa: 0.10%
5b5dd33b675d: 0.11%
6e98a9597e6a: 0.10%
```
+
. Format the output in a table. The results should include container name, percent CPU utilization and percent memory utilization. This can be achieved using the command:
+
```
docker container stats --format ""table {{.Name}}\\t{{.CPUPerc}}\\t{{.MemUsage}}""
```
+
It shows the output:
+
```
NAME                              CPU %               MEM USAGE / LIMIT
web.2.1ic0vevvvu2nwwyc6css58ref   0.10%               267.5MiB / 1.952GiB
web.3.pwcgr58s1xo28gwa1znlrn2s3   0.11%               274.7MiB / 1.952GiB
web.1.bg1dcwagl9tzz0azuegxzoys8   0.12%               274MiB / 1.952GiB
```
+
. Display only the first result using the command `docker container stats --no-stream`:
+
```
CONTAINER           CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
55198043b6aa        0.12%               267.5MiB / 1.952GiB   13.39%              1.44kB / 0B         0B / 4.1kB          51
5b5dd33b675d        0.07%               274.7MiB / 1.952GiB   13.75%              1.51kB / 0B         0B / 4.1kB          51
6e98a9597e6a        0.26%               274.1MiB / 1.952GiB   13.71%              1.69kB / 0B         0B / 4.1kB          51
```

== Docker Remote API

Docker Remote API provides a lot more details about the health of the container. It can be invoked using the following format:

    curl --unix-socket /var/run/docker.sock http://localhost/containers/<name>/stats

On Docker for Mac, enabling remote HTTP API still requires a few steps. So this command uses the `--unix-socket` option to invoke the Remote API.

A specific invocation for a container can be done as:

    curl --unix-socket /var/run/docker.sock http://localhost/containers/web.1.bg1dcwagl9tzz0azuegxzoys8/stats

Note, the container name is from the previous run of the service. It will show the output:

```
{""read"":""2017-10-13T14:08:38.045217731Z"",""preread"":""0001-01-01T00:00:00Z"",""pids_stats"":{""current"":51},""blkio_stats"":{""io_service_bytes_recursive"":[{""major"":8,""minor"":0,""op"":""Read"",""value"":0},{""major"":8,""minor"":0,""op"":""Write"",""value"":4096},{""major"":8,""minor"":0,""op"":""Sync"",""value"":0},{""major"":8,""minor"":0,""op"":""Async"",""value"":4096},{""major"":8,""minor"":0,""op"":""Total"",""value"":4096}],""io_serviced_recursive"":[{""major"":8,""minor"":0,""op"":""Read"",""value"":0},{""major"":8,""minor"":0,""op"":""Write"",""value"":1},{""major"":8,""minor"":0,""op"":""Sync"",""value"":0},{""major"":8,""minor"":0,""op"":""Async"",""value"":1},{""major"":8,""minor"":0,""op"":""Total"",""value"":1}],""io_queue_recursive"":[],""io_service_time_recursive"":[],""io_wait_time_recursive"":[],""io_merged_recursive"":[],""io_time_recursive"":[],""sectors_recursive"":[]},""num_procs"":0,""storage_stats"":{},""cpu_stats"":{""cpu_usage"":{""total_usage"":11130296115,""percpu_usage"":[2687118654,3014514615,2971860160,2456802686],""usage_in_kernelmode"":2700000000,""usage_in_usermode"":7630000000},""system_cpu_usage"":952826800000000,""online_cpus"":4,""throttling_data"":{""periods"":0,""throttled_periods"":0,""throttled_time"":0}},""precpu_stats"":{""cpu_usage"":{""total_usage"":0,""usage_in_kernelmode"":0,""usage_in_usermode"":0},""throttling_data"":{""periods"":0,""throttled_periods"":0,""throttled_time"":0}},""memory_stats"":{""usage"":288051200,""max_usage"":297189376,""stats"":{""active_anon"":283893760,""active_file"":0,""cache"":135168,""dirty"":16384,""hierarchical_memory_limit"":9223372036854771712,""hierarchical_memsw_limit"":9223372036854771712,""inactive_anon"":0,""inactive_file"":135168,""mapped_file"":32768,""pgfault"":83204,""pgmajfault"":0,""pgpgin"":78441,""pgpgout"":9093,""rss"":283914240,""rss_huge"":0,""swap"":0,""total_active_anon"":283893760,""total_active_file"":0,""total_cache"":135168,""total_dirty"":16384,""total_inactive_anon"":0,""total_inactive_file"":135168,""total_mapped_file"":32768,""total_pgfault"":83204,""total_pgmajfault"":0,""total_pgpgin"":78441,""total_pgpgout"":9093,""total_rss"":283914240,""total_rss_huge"":0,""total_swap"":0,""total_unevictable"":0,""total_writeback"":0,""unevictable"":0,""writeback"":0},""limit"":2095874048},""name"":""/web.1.bg1dcwagl9tzz0azuegxzoys8"",""id"":""6e98a9597e6af085e73a4d211fff9a164aa012727a46525d4fbaa164b572e23f"",""networks"":{""eth0"":{""rx_bytes"":1882,""rx_packets"":37,""rx_errors"":0,""rx_dropped"":0,""tx_bytes"":0,""tx_packets"":0,""tx_errors"":0,""tx_dropped"":0}}}
```

As you can see, far more details about container's health are shown here. These stats are refereshed every one second. The continuous refresh of metrics can be terminated using `Ctrl + C`.

== Docker Events

`docker system events` provide real time events for the Docker host.

. In one terminal (T1), type `docker system events`. The command does not show output and waits for any event worth reporting to occur. The list of events is listed at https://docs.docker.com/engine/reference/commandline/events/#/extended-description.
. In a new terminal (T2), kill existing container using `docker service scale web=2`.
. T1 shows the updated list of events as:
+
```
2017-10-13T07:12:00.223791013-07:00 service update r4i0x8ujnn2q8osj8dowgvw72 (name=web, replicas.new=2, replicas.old=3)
2017-10-13T07:12:00.332724880-07:00 container kill 5b5dd33b675d3b6be3e6aaf0ecde928b3ac882b0a221ff71e57c86faae8181ab (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=pwcgr58s1xo28gwa1znlrn2s3, com.docker.swarm.task.name=web.3.pwcgr58s1xo28gwa1znlrn2s3, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.3.pwcgr58s1xo28gwa1znlrn2s3, signal=15, vendor=CentOS)
2017-10-13T07:12:00.613143701-07:00 container die 5b5dd33b675d3b6be3e6aaf0ecde928b3ac882b0a221ff71e57c86faae8181ab (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=pwcgr58s1xo28gwa1znlrn2s3, com.docker.swarm.task.name=web.3.pwcgr58s1xo28gwa1znlrn2s3, exitCode=0, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.3.pwcgr58s1xo28gwa1znlrn2s3, vendor=CentOS)
2017-10-13T07:12:00.897831488-07:00 network disconnect 8f8e6ce771d6db6065f2472a7e83612ff6a657de3b6d08dab0617b8a596234fa (container=5b5dd33b675d3b6be3e6aaf0ecde928b3ac882b0a221ff71e57c86faae8181ab, name=bridge, type=bridge)
2017-10-13T07:12:01.017523717-07:00 container stop 5b5dd33b675d3b6be3e6aaf0ecde928b3ac882b0a221ff71e57c86faae8181ab (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=pwcgr58s1xo28gwa1znlrn2s3, com.docker.swarm.task.name=web.3.pwcgr58s1xo28gwa1znlrn2s3, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.3.pwcgr58s1xo28gwa1znlrn2s3, vendor=CentOS)
2017-10-13T07:12:01.023414108-07:00 container destroy 5b5dd33b675d3b6be3e6aaf0ecde928b3ac882b0a221ff71e57c86faae8181ab (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=pwcgr58s1xo28gwa1znlrn2s3, com.docker.swarm.task.name=web.3.pwcgr58s1xo28gwa1znlrn2s3, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.3.pwcgr58s1xo28gwa1znlrn2s3, vendor=CentOS)
```
+
The output shows a list of events, one in each line. The events shown here are `container kill`, `container die`, `network disconnect`, `container stop`, and `container destroy`. Date and timestamp for each event is displayed at the beginning of the line. Other event specific information is displayed as well.
+
. In T2, scale the service back to 3 replicas: `docker service scale web=3`
. The output in T1 is updated to show:
+
```
2017-10-13T07:13:47.161848609-07:00 service update r4i0x8ujnn2q8osj8dowgvw72 (name=web, replicas.new=3, replicas.old=2)
2017-10-13T07:13:47.429074382-07:00 container create 0574d1fd74bef2e6fc54174e1fbeda25efd7ed270dce1d6dbede4ead19c7c485 (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=xcmylcwlag5vot4tp3l5z6oam, com.docker.swarm.task.name=web.3.xcmylcwlag5vot4tp3l5z6oam, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.3.xcmylcwlag5vot4tp3l5z6oam, vendor=CentOS)
2017-10-13T07:13:47.445010259-07:00 network connect 8f8e6ce771d6db6065f2472a7e83612ff6a657de3b6d08dab0617b8a596234fa (container=0574d1fd74bef2e6fc54174e1fbeda25efd7ed270dce1d6dbede4ead19c7c485, name=bridge, type=bridge)
2017-10-13T07:13:47.778855117-07:00 container start 0574d1fd74bef2e6fc54174e1fbeda25efd7ed270dce1d6dbede4ead19c7c485 (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=xcmylcwlag5vot4tp3l5z6oam, com.docker.swarm.task.name=web.3.xcmylcwlag5vot4tp3l5z6oam, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.3.xcmylcwlag5vot4tp3l5z6oam, vendor=CentOS)
```
+
The list of events shown here are `container create`, `network connect`, and `container start`.

=== Use filters

The list of events can be restricted by filters specified using `--filter` or `-f` option. The currently supported filters are:

. container (`container=<name or id>`)
. daemon (`daemon=<name or id>`)
. event (`event=<event action>`)
. image (`image=<tag or id>`)
. label (`label=<key>` or `label=<key>=<value>`)
. network (`network=<name or id>`)
. plugin (`plugin=<name or id>`)
. type (`type=<container or image or volume or network or daemon>`)
. volume (`volume=<name or id>`)

Let's look at the list of running containers first using `docker container ls`, and then learn how to apply these filters.

Here is the list of running containers from the service:

```
CONTAINER ID        IMAGE                  COMMAND                  CREATED             STATUS              PORTS               NAMES
074447f26452        jboss/wildfly:latest   ""/opt/jboss/wildfl...""   3 minutes ago       Up 3 minutes        8080/tcp            web.1.ytyv0gqi7dzxtetssrlsgvvbu
0574d1fd74be        jboss/wildfly:latest   ""/opt/jboss/wildfl...""   8 minutes ago       Up 8 minutes        8080/tcp            web.3.xcmylcwlag5vot4tp3l5z6oam
55198043b6aa        jboss/wildfly:latest   ""/opt/jboss/wildfl...""   25 minutes ago      Up 25 minutes       8080/tcp            web.2.1ic0vevvvu2nwwyc6css58ref
```

Let's apply the filters.

. Show events for a container by name
.. In T1, give the command to listen to a specific container as:
+
```
docker system events -f container=web.1.ytyv0gqi7dzxtetssrlsgvvbu
```
+
You may have to terminate previous run of `docker system events` using `Ctrl` + `C` to give this new command. 
+
.. In T2, terminate the second replica of the service as `docker container rm -f web.2.1ic0vevvvu2nwwyc6css58ref`. 
.. T1 does not show any events because its only listening for events from the first replica of the service.
. Show events for an event
.. In T1, give the command `docker system events -f event=create`.
.. In T2, scale the service by one more replica:
+
```
docker service scale web=4
```
.. T1 shows the event for container creation
+
```
2017-10-13T07:24:22.971050949-07:00 container create 84e4604ffd983cfcc53ad619b4c11156518834fe23e4a0a8b299905b978a0022 (build-date=20170911, com.docker.swarm.node.id=wgujclh0492kkszpil81d3ugb, com.docker.swarm.service.id=r4i0x8ujnn2q8osj8dowgvw72, com.docker.swarm.service.name=web, com.docker.swarm.task=, com.docker.swarm.task.id=38unfmcsxmnvr844gysn28lwa, com.docker.swarm.task.name=web.4.38unfmcsxmnvr844gysn28lwa, image=jboss/wildfly:latest@sha256:d3af084d024753e4799809c10cd188f675a5b254a8e279b34709035b95d27dc7, license=GPLv2, name=web.4.38unfmcsxmnvr844gysn28lwa, vendor=CentOS)
```
+
This is accurate as a new container is created and the event is shown in T1 console.
.. In T2, scale the service back to 2 using the command `docker servie scale web=2`
.. T1 does not show any additional events because its only looking for create events
.. More samples are explained at https://docs.docker.com/engine/reference/commandline/events/#/filter-events-by-criteria.

== Prometheus

https://prometheus.io/[Prometheus] is an open-source systems monitoring and alerting toolkit. Prometheus collects metrics from monitored targets by scraping metrics from HTTP endpoints on these targets. Docker instance can be configured as Prometheus target.

Different targets to scrape are defined in the https://prometheus.io/docs/operating/configuration/[Prometheus configuration file]. Targets may be statically configured via the `static_configs` parameter in the configuration fle or dynamically discovered using one of the supported service-discovery mechanisms (Consul, DNS, Etcd, etc.).

Prometheus collects metrics from monitored targets by scraping metrics from HTTP endpoints on these targets. Since Prometheus also exposes data in the same manner about itself, it can also scrape and monitor its own health.

=== Docker metrics for Prometheus

Docker exposes Prometheus-compatible metrics on port `9323`. This support is only available as an experimental feature.

. For Docker for Mac, click on Docker icon in the status menu
. Select `Preferences...`, `Daemon`, `Advanced` tab
. Update daemon settings:
+
```
{
  ""metrics-addr"" : ""0.0.0.0:9323"",
  ""experimental"" : true
}
```
+
. Click on `Apply & Restart` to restart the daemon
+
image::prometheus-metrics-config.png[]
+
. Show the complete list of metrics using `curl http://localhost:9323/metrics`
. Show the list of engine metrics using `curl http://localhost:9323/metrics | grep engine`

==== Start Prometheus

In this section, we'll start Prometheus and use it to scrape it's own health.

. Create a new directory `prometheus` and change to that directory
. Create a text file `prometheus.yml` and use the following content
+
```
# A scrape configuration scraping a Node Exporter and the Prometheus server
# itself.
scrape_configs:
  # Scrape Prometheus itself every 5 seconds.
  - job_name: 'prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:9090']
```
+
This configuration file scrapes data from the Prometheus container which will be started subsequently on port 9090.
+
. Start a single-replica Prometheus service:
+
```
docker service create \\
  --replicas 1 \\
  --name metrics \\
  --mount type=bind,source=`pwd`/prometheus.yml,destination=/etc/prometheus/prometheus.yml \\
  --publish 9090:9090/tcp \\
  prom/prometheus
```
+
This will start the Prometheus container on port 9090.
+
. Prometheus dashboard is at http://localhost:9090. Check the list of enabled targets at http://localhost:9090/targets (also accessible from `Status` -> `Targets` menu).
+
image::prometheus-metrics-target.png[]
+
It shows that the Prometheus endpoint is available for scraping.
+
. Click on `Graph` and click on `-insert metric at cursor-` to see the list of metrics available:
+
image::prometheus-metrics1.png[]
+
These are all the metrics published by the Prometheus endpoint.
+
. Choose `http_request_total` metrics, click on `Execute`
+
image::prometheus-metrics2.png[]
+
. Switch from `Console` to `Graph`
+
image::prometheus-metrics3.png[]
+
. Change the duration from `1h` to `5m`
+
image::prometheus-metrics4.png[]
+
. Click on `Add Graph`, select a different metric, say `http_requests_duration_microseconds`, and click on `Execute`
+
image::prometheus-metrics5.png[]
+
. Switch from `Console` to `Graph` and change the duration from `1h` to `5m`
+
image::prometheus-metrics6.png[]
+
. Stop the container: `docker container rm -f metrics`

Multiple graphs can be added this way.

=== Node health

In this section, we'll start Prometheus node exporter that will publish machine metrics. Then we'll use Prometheus to scrape its health information about the node running Docker.

==== Start Node Exporter

. All containers need to use the same overlay network so that they can communicate with each other. Let's create an overlay network:
+
```
docker network create --driver overlay prom
```
+
. Start Prometheus node exporter:
+
```
docker service create --name node \\
 --mode global \\
 --mount type=bind,source=/proc,target=/host/proc \\
 --mount type=bind,source=/sys,target=/host/sys \\
 --mount type=bind,source=/,target=/rootfs \\
 --network prom \\
 --publish 9100:9100 \\
 prom/node-exporter:v0.15.0 \\
  --path.procfs /host/proc \\
  --path.sysfs /host/sys \\
  --collector.filesystem.ignored-mount-points ""^/(sys|proc|dev|host|etc)($|/)""
```
+
A few observations in this command:
+
.. This is started as a global service such that it is started on all nodes of the cluster.
.. As explained in https://github.com/prometheus/node_exporter/issues/610, node exporter only works with host network on Mac OSX. This is not needed if you are running on Linux.
.. It uses the overlay network previously created.
.. It needs access to host's filesystems such that the metrics about the node can be published.

==== Restart Prometheus

. Update `prometheus.yml` to the following text:
+
```
global:
  scrape_interval: 10s
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets:
        - 'localhost:9090'
  - job_name: 'node resources'
    dns_sd_configs:
      - names: ['tasks.node']
        type: 'A'
        port: 9100
    params:
      collect[]:
        - cpu
        - meminfo
        - diskstats
        - netdev
        - netstat

  - job_name: 'node storage'
    scrape_interval: 1m
    dns_sd_configs:
      - names: ['tasks.node']
        type: 'A'
        port: 9100
    params:
      collect[]:
        - filefd
        - filesystem
        - xfs
```
+
A few observations:
+
.. DNS-based service discovery is used to discover the scraper for node-exporter. This is further explained at https://prometheus.io/docs/operating/configuration/#<dns_sd_config>[dns_sd_configs]. A record-based queries are used to discover the service.
.. Two different jobs are created even though they are scraping from the same endpoint. This provides a more logical way to represent data.
+
. Terminate previously running Prometheus service:
+
```
docker service rm metrics
```
+
. Restart the Prometheus service, this time using the overlay network, as:
+
```
docker service create \\
  --replicas 1 \\
  --name metrics \\
  --network prom \\
  --mount type=bind,source=`pwd`/prometheus.yml,destination=/etc/prometheus/prometheus.yml \\
  --publish 9090:9090/tcp \\
  prom/prometheus
```

==== Check metrics

. Confirm that both the services have started:
+
```
ID                  NAME                MODE                REPLICAS            IMAGE                       PORTS
lzl41s2i66jd        metrics             replicated          1/1                 prom/prometheus:latest      *:9090->9090/tcp
dro3ncpyuchp        node                global              1/1                 prom/node-exporter:latest   
```
+
. Confirm that all the targets are configured correctly at http://localhost:9090/targets[Prometheus dashboard]:
+
image::prometheus-metrics-target2.png[]
+
. Now a lot more metrics, this time from the node, are also available:
+
image::prometheus-metrics7.png[]
+
Console output and graphs for all these metrics is now available:
+
image::prometheus-metrics8.png[]
+
Complete list of metrics is available at https://github.com/prometheus/node_exporter.

=== Query using PromQL (TODO)

Add some fun queries from https://prometheus.io/docs/querying/basics/.

== cAdvisor

https://github.com/google/cadvisor[cAdvisor] (Container Advisor) provides resource usage and performance characteristics running containers. Let's take a look on how cAdvisor can be used to get these metrics from containers.

. Run `cAdvisor`
+
```
docker container run \\
  --volume=/:/rootfs:ro \\
  --volume=/var/run:/var/run:rw \\
  --volume=/sys:/sys:ro \\
  --volume=/var/lib/docker/:/var/lib/docker:ro \\
  --publish=8080:8080 \\
  --detach=true \\
  --name=cadvisor \\
  google/cadvisor:latest
```
+
. Dashboard is available at http://localhost:8080
+
image::cadvisor-default-dashboard.png[]
+
. A high-level CPU and Memory utilization is shown. More details about CPU, memory, network and filesystem usage is shown in the same page. CPU usage looks like as shown:
+
image::cadvisor-cpu-snapshot.png[]
+
. All Docker containers are in `/docker` sub-container.
+
image::cadvisor-docker-metrics.png[]
+
Click on any of the containers and see more details about the container.

cAdvisor samples once a second and has historical data for only one minute. The data generated from https://github.com/google/cadvisor/blob/master/docs/storage/influxdb.md[cAdvisor can be exported to InfluxDB]. Optionally, you may use a Grafana front end to visualize the data as explained in https://www.brianchristner.io/how-to-setup-docker-monitoring/[How to setup Docker monitoring].

=== Prometheus and cAdvisor

cAdvisor also exposes container statistics as Prometheus metrics out of the box. By default, these metrics are served under the `/metrics` HTTP endpoint. Let's take a look at how these container metrics can be observed using Prometheus.

. Terminate previously running cAdvisor:
+
```
docker container rm -f cadvisor
```
+
. Start a new cAdvisor service, using the `prom` overlay network created earlier:
+
```
docker service create \\
  --name cadvisor \\
  --network prom \\
  --mode global \\
  --mount type=bind,source=/,target=/rootfs \\
  --mount type=bind,source=/var/run,target=/var/run \\
  --mount type=bind,source=/sys,target=/sys \\
  --mount type=bind,source=/var/lib/docker,target=/var/lib/docker \\
  google/cadvisor:latest
```
+
. Terminate the previously running Prometheus service:
+
```
docker service rm metrics
```
+
. The update `prometheus.yml` configuration file is:
+
```
global:
  scrape_interval: 10s
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets:
        - 'localhost:9090'

  - job_name: 'node resources'
    dns_sd_configs:
      - names: ['tasks.node']
        type: 'A'
        port: 9100
    params:
      collect[]:
        - cpu
        - meminfo
        - diskstats
        - netdev
        - netstat

  - job_name: 'node storage'
    scrape_interval: 1m
    dns_sd_configs:
      - names: ['tasks.node']
        type: 'A'
        port: 9100
    params:
      collect[]:
        - filefd
        - filesystem
        - xfs

  - job_name: 'cadvisor'
    dns_sd_configs:
      - names: ['tasks.cadvisor']
        type: 'A'
        port: 8080
```
+
. Start the new Prometheus service
+
```
docker service create \\
  --replicas 1 \\
  --name metrics \\
  --network prom \\
  --mount type=bind,source=`pwd`/prometheus.yml,destination=/etc/prometheus/prometheus.yml \\
  --publish 9090:9090/tcp \\
  prom/prometheus
```
+
. Confirm that all the targets are configured correctly at http://localhost:9090/targets[Prometheus dashboard]:
+
image::prometheus-metrics-target3.png[]
+
Note, all four scrape endpoints are shown here.
+
. In Graphs, now, a lot more metrics, this time from cAdvisor, are also available:
+
image::prometheus-metrics9.png[]
+
Console output and graphs for all these metrics is now available:
+
image::prometheus-metrics10.png[]
+
Complete list of metrics is available at https://github.com/google/cadvisor.

Here is a basic query written using https://prometheus.io/docs/querying/basics/[PromQL] worth trying:

```
sum by (container_label_com_docker_swarm_node_id) (
  irate(
    container_cpu_usage_seconds_total{
      container_label_com_docker_swarm_service_name=""metrics""
      }[1m]
  )
)
```

This shows the average amount of CPU used per minute by the service `metrics` aggregated over multiple CPUs. The graph will look as shown:

image::prometheus-metrics11.png[]


== Monitor Java Applications

This section will explain how an existing Java application can be updated to publish metrics and monitored by Prometheus.

Prometheus collects metrics from monitored targets by scraping metrics HTTP endpoints on these targets.

As discussed earlier, Prometheus collects metrics from monitored targets by scraping from an HTTP endpoint on these targets. By default, these metrics are expected to be published at `/metrics`. Any existing Java application can be updated to publish Prometheus-style metrics at this endpoint.

An link:ch05-compose.adoc#configuration-file[earlier chapter] explained a simple Java EE application that talks to a MySQL database. This application also publishes Prometheus-style metrics for the underlying JVM at `/metrics`. It also publishes application-specific metrics such as total number of times `GET /` and `GET /{id}` is called.

The complete set of JVM metrics are explained at https://github.com/prometheus/client_java. Refer to https://github.com/arun-gupta/docker-javaee/tree/master/employees/src/main/java/org/javaee/samples/employees/metrics for more details on how these metrics are enabled. 

=== Start Java application

. Use the link:ch05-compose.adoc#configuration-file[Compose file] to deploy a simple the Java EE application. This will start WildFly Swarm application and MySQL database.
+
    docker stack deploy --compose-file=docker-compose.yml webapp
+
This will create `webapp_default` overlay network, and start the `webapp_web` and `webapp_db` services.
+
. Verify the network:
+
```
$ docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
u6ybdaqx5h5y        webapp_default      overlay             swarm
```
+
Other networks may be shown here as well.
+
. Verify the services:
+
```
$ docker service ls
ID                  NAME                MODE                REPLICAS            IMAGE                            PORTS
ucztcpf1vw0a        webapp_db           replicated          1/1                 mysql:8                          *:3306->3306/tcp
jttfgvr09kre        webapp_web          replicated          1/1                 arungupta/docker-javaee:latest   *:8080->8080/tcp,*:9990->9990/tcp
```
+
. Verify that the endpoint is accessible:
+
```
$ curl http://localhost:8080/resources/employees
<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?><collection><employee><id>1</id><name>Penny</name></employee><employee><id>2</id><name>Sheldon</name></employee><employee><id>3</id><name>Amy</name></employee><employee><id>4</id><name>Leonard</name></employee><employee><id>5</id><name>Bernadette</name></employee><employee><id>6</id><name>Raj</name></employee><employee><id>7</id><name>Howard</name></employee><employee><id>8</id><name>Priya</name></employee></collection>
```
+
. Access the metrics published by the endpoint using `curl http://localhost:8080/metrics` to see the output:
+
```
# HELP jvm_info JVM version info
# TYPE jvm_info gauge
jvm_info{version=""1.8.0_141-8u141-b15-1~deb9u1-b15"",vendor=""Oracle Corporation"",} 1.0
# HELP jvm_gc_collection_seconds Time spent in a given JVM garbage collector in seconds.
# TYPE jvm_gc_collection_seconds summary
jvm_gc_collection_seconds_count{gc=""PS Scavenge"",} 25.0
jvm_gc_collection_seconds_sum{gc=""PS Scavenge"",} 0.386
jvm_gc_collection_seconds_count{gc=""PS MarkSweep"",} 6.0
jvm_gc_collection_seconds_sum{gc=""PS MarkSweep"",} 0.546
# HELP process_cpu_seconds_total Total user and system CPU time spent in seconds.
# TYPE process_cpu_seconds_total counter
process_cpu_seconds_total 25.5
# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.
# TYPE process_start_time_seconds gauge
process_start_time_seconds 1.508056592419E9
# HELP process_open_fds Number of open file descriptors.
# TYPE process_open_fds gauge
process_open_fds 499.0
# HELP process_max_fds Maximum number of open file descriptors.
# TYPE process_max_fds gauge
process_max_fds 1048576.0
# HELP process_virtual_memory_bytes Virtual memory size in bytes.
# TYPE process_virtual_memory_bytes gauge
process_virtual_memory_bytes 4.244393984E9
# HELP process_resident_memory_bytes Resident memory size in bytes.
# TYPE process_resident_memory_bytes gauge
process_resident_memory_bytes 5.06601472E8
# HELP jvm_classes_loaded The number of classes that are currently loaded in the JVM
# TYPE jvm_classes_loaded gauge
jvm_classes_loaded 13096.0
# HELP jvm_classes_loaded_total The total number of classes that have been loaded since the JVM has started execution
# TYPE jvm_classes_loaded_total counter
jvm_classes_loaded_total 13096.0
# HELP jvm_classes_unloaded_total The total number of classes that have been unloaded since the JVM has started execution
# TYPE jvm_classes_unloaded_total counter
jvm_classes_unloaded_total 0.0
# HELP jvm_threads_current Current thread count of a JVM
# TYPE jvm_threads_current gauge
jvm_threads_current 60.0
# HELP jvm_threads_daemon Daemon thread count of a JVM
# TYPE jvm_threads_daemon gauge
jvm_threads_daemon 12.0
# HELP jvm_threads_peak Peak thread count of a JVM
# TYPE jvm_threads_peak gauge
jvm_threads_peak 67.0
# HELP jvm_threads_started_total Started thread count of a JVM
# TYPE jvm_threads_started_total counter
jvm_threads_started_total 93.0
# HELP jvm_threads_deadlocked Cycles of JVM-threads that are in deadlock waiting to acquire object monitors or ownable synchronizers
# TYPE jvm_threads_deadlocked gauge
jvm_threads_deadlocked 0.0
# HELP jvm_threads_deadlocked_monitor Cycles of JVM-threads that are in deadlock waiting to acquire object monitors
# TYPE jvm_threads_deadlocked_monitor gauge
jvm_threads_deadlocked_monitor 0.0
# HELP jvm_memory_bytes_used Used bytes of a given JVM memory area.
# TYPE jvm_memory_bytes_used gauge
jvm_memory_bytes_used{area=""heap"",} 1.2072508E8
jvm_memory_bytes_used{area=""nonheap"",} 9.3550048E7
# HELP jvm_memory_bytes_committed Committed (bytes) of a given JVM memory area.
# TYPE jvm_memory_bytes_committed gauge
jvm_memory_bytes_committed{area=""heap"",} 2.69484032E8
jvm_memory_bytes_committed{area=""nonheap"",} 1.0133504E8
# HELP jvm_memory_bytes_max Max (bytes) of a given JVM memory area.
# TYPE jvm_memory_bytes_max gauge
jvm_memory_bytes_max{area=""heap"",} 4.66092032E8
jvm_memory_bytes_max{area=""nonheap"",} -1.0
# HELP jvm_memory_pool_bytes_used Used bytes of a given JVM memory pool.
# TYPE jvm_memory_pool_bytes_used gauge
jvm_memory_pool_bytes_used{pool=""Code Cache"",} 1.4589888E7
jvm_memory_pool_bytes_used{pool=""Metaspace"",} 6.9998048E7
jvm_memory_pool_bytes_used{pool=""Compressed Class Space"",} 8962112.0
jvm_memory_pool_bytes_used{pool=""PS Eden Space"",} 2.3732032E7
jvm_memory_pool_bytes_used{pool=""PS Survivor Space"",} 6073592.0
jvm_memory_pool_bytes_used{pool=""PS Old Gen"",} 9.0919456E7
# HELP jvm_memory_pool_bytes_committed Committed bytes of a given JVM memory pool.
# TYPE jvm_memory_pool_bytes_committed gauge
jvm_memory_pool_bytes_committed{pool=""Code Cache"",} 1.47456E7
jvm_memory_pool_bytes_committed{pool=""Metaspace"",} 7.5800576E7
jvm_memory_pool_bytes_committed{pool=""Compressed Class Space"",} 1.0788864E7
jvm_memory_pool_bytes_committed{pool=""PS Eden Space"",} 9.2274688E7
jvm_memory_pool_bytes_committed{pool=""PS Survivor Space"",} 3.8797312E7
jvm_memory_pool_bytes_committed{pool=""PS Old Gen"",} 1.38412032E8
# HELP jvm_memory_pool_bytes_max Max bytes of a given JVM memory pool.
# TYPE jvm_memory_pool_bytes_max gauge
jvm_memory_pool_bytes_max{pool=""Code Cache"",} 2.5165824E8
jvm_memory_pool_bytes_max{pool=""Metaspace"",} -1.0
jvm_memory_pool_bytes_max{pool=""Compressed Class Space"",} 1.073741824E9
jvm_memory_pool_bytes_max{pool=""PS Eden Space"",} 9.699328E7
jvm_memory_pool_bytes_max{pool=""PS Survivor Space"",} 3.8797312E7
jvm_memory_pool_bytes_max{pool=""PS Old Gen"",} 3.49700096E8
```
+
It shows all the JVM metrics that are published by the https://github.com/prometheus/client_java[Prometheus JVM Client]. The metrics generated by the application are not shown yet. It requires for the application to be accessed first.

Let's access the JVM metrics in Prometheus dashboard first, and then we'll access the app to show app-specific metrics.

=== Start Prometheus service

. Make sure to terminate any previously running Prometheus endpoints:
+
   docker service rm metrics
+
. Create a directory `prometheus` and change into that directory.
. Create a text file `prometheus.yml` and add the following content:
+
```
global:
  scrape_interval: 10s
scrape_configs:
  - job_name: 'webapp'
    dns_sd_configs:
      - names: ['tasks.webapp_web']
        type: 'A'
        port: 8080
```
+
This defines the configuration for the HTTP endpoint that publishes Prometheus-style metrics from the Java application.
+
. Start Prometheus service:
+
```
docker service create \\
  --replicas 1 \\
  --network webapp_default \\
  --name metrics \\
  --mount type=bind,source=`pwd`/prometheus.yml,destination=/etc/prometheus/prometheus.yml \\
  --publish 9090:9090 \\
  prom/prometheus
```
+
Note, this service is using the `webapp_default` overlay network that is created when the application stack was deployed.
+
. Access Prometheus dashboard at http://localhost:9090
. Check the configured targets at http://localhost:9090/targets:
+
image::prometheus-metrics-target4.png[]
+
It shows that the application metrics HTTP endpoint is configured as a Prometheus target.

=== View application metrics

. On Prometheus dashboard, click on `-insert metric at cursor-` to see the list of metrics available:
+
image::prometheus-metrics12.png[]
+
JVM metrics shown earlier are displayed here as well.
+
. Select `jvm_memory_pool_bytes_used` metric and click on `Execute` to view the metric.
+
image::prometheus-metrics13.png[]
+
. Select `Graph` to view the graphical representation
+
image::prometheus-metrics14.png[]
+
. Now access the application using `curl http://localhost:8080/resources/employees` a few times.
. Refresh Prometheus dashboard and see the updated list of metrics:
+
image::prometheus-metrics15.png[]
+
Note, `app*` and `requests*` that are generated by the application.
+
. Select `requests_get_all` metric and view the graph:
+
image::prometheus-metrics16.png[]
+
. Access the application a few times using `curl http://localhost:8080/resources/employees/5` and then watch the `requests_get_one` metric.

== Grafana

https://github.com/grafana/grafana[Grafana] is an open source metric analytics & visualization suite. It supports many different storage backends, called as Data Source. Prometheus can be added as Grafana data source. It even provides support for runnning Prometheus queries from the Grafana dashboard as well. More details can be found in http://docs.grafana.org/features/datasources/prometheus/[Using Prometheus in Grafana].

=== Start Grafana

This section will explain how to start Grafana, use Prometheus as the data source, and view some container metrics.

. Start Grafana:
+
```
docker container run \\
  -d \\
  -p 3000:3000 \\
  --name=grafana \\
  -e ""GF_SECURITY_ADMIN_PASSWORD=secret"" \\
  grafana/grafana
```
+
Use the login name `admin` and password `secret`.
+
Read more details about different http://docs.grafana.org/installation/configuration/[configuration options].
+
. Access Grafana dashboard at http://localhost:3000. Use the login and password as credentials to see Grafana console.
+
image::grafana-metrics1.png[]

=== Add Prometheus as data source

. Click the `Add data source` button in the top header.
. Specify the parameters as shown:
+
image::grafana-metrics2.png[]
+
. Click on `Add` to test and save the data source:
+
image::grafana-metrics3.png[]
+
The green bar indicates that the data source was added successfully.

=== Create chart with Prometheus data source

. Click on `Create your first dashboard`, save it and give it a name, say `Docker and Java dashboard`
. Click on `Graph`, edit, under the `Metrics` tab, select your Prometheus data source.
. Enter the following Prometheus query expressions in the query field. The graphs will referesh in a few seconds and will look like as shown:
+
image::grafana-metrics4.png[]

",12400,False,1838.4085303157453,median
"---
title: Бүлэг 24. Локалчлал - I18N/L10N-ийн хэрэглээ болон тохируулга
part: хэсэг III. Системийн Удирдлага
prev: books/handbook/virtualization
next: books/handbook/cutting-edge
---

[[l10n]]
= Локалчлал - I18N/L10N-ийн хэрэглээ болон тохируулга
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 24
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/l10n/

ifdef::env-beastie[]
ifdef::backend-html5[]
:imagesdir: ../../../../images/{images-path}
endif::[]
ifndef::book[]
include::shared/authors.adoc[]
include::shared/mirrors.adoc[]
include::shared/releases.adoc[]
include::shared/attributes/attributes-{{% lang %}}.adoc[]
include::shared/{{% lang %}}/teams.adoc[]
include::shared/{{% lang %}}/mailing-lists.adoc[]
include::shared/{{% lang %}}/urls.adoc[]
toc::[]
endif::[]
ifdef::backend-pdf,backend-epub3[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]
endif::[]

ifndef::env-beastie[]
toc::[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]

[[l10n-synopsis]]
== Ерөнхий агуулга

FreeBSD нь дэлхий даяар байрласан хэрэглэгчид болон хувь нэмэр болгон оруулагчидтай маш тархмал төсөл юм. Энэ бүлэг Англиар ярьдаггүй хэрэглэгчдэд жинхэнэ ажлаа хийх боломж олгох FreeBSD-ийн интернационалчлал болон локалчлалын боломжуудыг хэлэлцэх болно. Систем болон програмын түвшингүүдийн аль алинд нь i18n шийдлийн олон үзэл бодлууд байдаг бөгөөд бид шаардлагатай тохиолдолд илүү тусгайлсан баримтын эхүүдийг хэрэглэгчдэд зааж өгөх болно.

Энэ бүлгийг уншсаны дараа, та дараах зүйлсийг мэдэх болно:

* Орчин үеийн үйлдлийн системүүд дээр хэлнүүд болон локалууд (locales) нь хэрхэн кодчилогддог талаар.
* Өөрийн нэвтрэх бүрхүүлийн хувьд локалыг хэрхэн тохируулах талаар.
* Англи биш хэлнүүдийн хувьд өөрийн консолыг хэрхэн тохируулах талаар.
* X Цонхны Системийг өөр хэлнүүдтэй хэрхэн үр дүнтэйгээр ашиглах талаар.
* i18n-нийцтэй програмуудыг бичих талаар илүү мэдээллийг хаанаас олох талаар.

Энэ бүлгийг уншихаасаа өмнө, та дараах зүйлсийг мэдэх шаардлагатай:

* Нэмэлт гуравдагч этгээдийн програмуудыг (crossref:ports[ports,Програм суулгах. Багцууд болон портууд]) хэрхэн суулгах талаар.

[[l10n-basics]]
== Үндсүүд

=== I18N/L10N гэж юу вэ?

Хөгжүүлэгчид интернационалчлалыг I18N гэж internationalization гэсэн үгийн эхний болон эцсийн үсгийн хоорондох үсгийн тоог оруулан богиносгосон юм. L10N нь бас адил журмаар ""localization""-с улбаалан нэрлэгдсэн юм. Хоёулаа нэгдсэн I18N/L10N аргууд, протоколууд болон програмууд нь хэрэглэгчдэд өөрсдийнх нь сонгосон хэлнүүдийг ашиглах боломжийг олгодог.

I18N програмууд нь сангуудын доорх I18N хэрэгслүүдийг ашиглан програмчлагдсан байдаг. Энэ нь энгийн файлыг бичих болон харуулагдсан цэснүүд, текстүүдийг хэл бүр уруу орчуулах боломжийг хөгжүүлэгчдэд олгоно. Бид энэ дадлыг мөрдөхийг програм зохиогчдоос шаргуу хүсдэг.

=== I18N/L10N-ийг би яагаад ашиглах ёстой гэж?

I18N/L10N нь Англи хэлнээс өөр хэл дээр өгөгдлийг харах, оруулах, эсвэл боловсруулахыг таныг хүсэх үед хэрэглэгддэг.

=== I18N чармайлтад ямар хэлнүүд дэмжигдсэн байдаг вэ?

I18N болон L10N нь зөвхөн FreeBSD зориулагдаагүй. Одоогоор хэрэглэгч дэлхийн гол гол хэлнүүдийн ихэнхийг сонгож болох бөгөөд гэхдээ энэ нь энд байгаа жагсаалтаар хязгаарлагдахгүй: Хятад, Герман, Япон, Солонгос, Франц, Орос, Вьетнам болон бусад хэлнүүдийг дурдаж болно.

[[using-localization]]
== Локалчлалыг ашиглах нь

Өөрийн бүх сүр жавхлангаараа I18N нь зөвхөн FreeBSD-д зориулагдаагүй бөгөөд энэ нь ёс заншил болсон байдаг. Энэ ёс заншлыг дагаж FreeBSD-д туслахыг бид танаас хүсдэг.

Локалчлалын тохируулгууд нь гурван гол ойлголт дээр тулгуурладаг: Хэлний код, Улсын код ба Кодчилол. Локалын нэрс эдгээр хэсгүүдээс дараах маягаар бүрэлдэн тогтоно:

[.programlisting]
....
LanguageCode_CountryCode.Encoding
....

=== Хэл болон Улсын кодууд

FreeBSD системийг тухайн хэл уруу (эсвэл I18N дэмждэг бусад UNIX(R) төст системүүд дээр) локалчлахын тулд хэрэглэгч тухайн улс болон хэлийг (улсын код нь програмд өгөгдсөн хэлний аль хувилбарыг ашиглахыг хэлж өгдөг) заах кодуудыг олж мэдэх хэрэгтэй. Мөн вэб хөтчүүд, SMTP/POP серверүүд зэрэг нь тэдгээр дээр тулгуурлан шийдэл гаргадаг. Дараах нь хэл/улсын кодны жишээнүүд юм:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Хэл/Улсын код
| Тайлбар

|en_US
|English буюу Англи - Нэгдсэн Улс

|ru_RU
|Орос улсад зориулсан Russian буюу Орос

|zh_TW
|Тайваньд зориулсан Уламжлалт Хятад хэл
|===

Байгаа локалчлалын жагсаалтыг дараах тушаалаар авч болно:

[source,shell]
....
% locale -a
....

=== Кодчилолууд

Зарим хэлнүүд 8-бит, өргөн эсвэл олон байт тэмдэгтүүд зэрэг ASCII биш кодчилолыг ашигладаг. Олон байт тэмдэгтүүдийн талаар илүү дэлгэрэнгүйг man:multibyte[3]-ээс үзнэ үү. Хуучин програмууд тэдгээрийг танидаггүй бөгөөд тэдгээрийг хянах тэмдэгтүүд гэж алддаг. Шинэ програмууд ихэвчлэн 8-бит тэмдэгтүүдийг танидаг. Шийдлээс хамаараад хэрэглэгчид програмыг өргөн эсвэл олон байт тэмдэгтийн дэмжлэгтэйгээр эмхэтгэх эсвэл зөвөөр тохируулах шаардлагатай байж болох юм. Өргөн эсвэл олон тэмдэгтүүдийг оруулж процесс хийж чадахын тулд link:https://www.FreeBSD.org/ports/[FreeBSD портын цуглуулга] хэл бүрийг өөр өөр програмуудтайгаар хангадаг. FreeBSD порт дахь харгалзах I18N баримтжуулалтаас лавлана уу.

Ялангуяа програмыг хэрхэн зөв тохируулах эсвэл зөв утгуудыг configure/Makefile/эмхэтгэгчид дамжуулахыг шийдэхдээ програмын баримтжуулалтаас харах хэрэгтэй болно.

Санаж байх ёстой зарим нэг зүйлүүд нь:

* Тухайн хэлний ганц C chars тэмдэгтийн олонлогууд (man:multibyte[3]-г үзнэ үү), өөрөөр хэлбэл ISO8859-1, ISO8859-15, KOI8-R, CP437.
* Өргөн эсвэл олон байт кодчилол, өөрөөр хэлбэл EUC, Big5.

Та тэмдэгтийн олонлогуудын идэвхтэй жагсаалтыг http://www.iana.org/assignments/character-sets[IANA Registry]-с шалгаж болно.

[NOTE]
====
FreeBSD нь X11-нийцтэй локалын кодчилолуудыг харин ашигладаг.
====

=== I18N програмууд

FreeBSD-ийн портууд болон багцын системд I18N програмууд нь амархан танигдахын тулд нэрэндээ `I18N`-тайгаар нэрлэгддэг. Гэхдээ тэдгээр нь хэрэгтэй хэлийг үргэлж дэмжсэн байдаггүй.

[[setting-locale]]
=== Локалыг тохируулах

Нэвтрэх бүрхүүл дээр локалын нэрний утгыг `LANG` уруу экспорт хийхэд ихэвчлэн хангалттай байдаг. Үүнийг хэрэглэгчийн [.filename]#~/.login_conf# файл эсвэл хэрэглэгчийн бүрхүүлийн эхлүүлэх файлд ([.filename]#~/.profile#, [.filename]#~/.bashrc#, [.filename]#~/.cshrc#) зааж өгч болно. `LC_CTYPE`, `LC_CTIME` зэрэг локал дэд олонлогуудыг тохируулах хэрэггүй. Дэлгэрэнгүй мэдээллийн талаар тухайн хэлний FreeBSD-ийн баримтаас лавлана уу.

Та өөрийн тохиргооны файлууддаа дараах хоёр орчны хувьсагчийг тохируулах хэрэгтэй:

* POSIX(R) man:setlocale[3] төрлийн функцуудад зориулсан `LANG`
* Програмуудын MIME тэмдэгтийн олонлогт зориулсан `MM_CHARSET`

Энэ нь хэрэглэгчийн бүрхүүлийн тохиргоо, тухайн програмын тохиргоо болон X11-ийн тохиргоог агуулдаг.

==== Локал аргуудыг тохируулах

Локалыг тохируулах хоёр арга байдаг бөгөөд хоёуланг доор тайлбарласан байгаа. Эхнийхийг (бидний зөвлөж байгааг) <<login-class,нэвтрэх ангилал>>д орчны хувьсагчуудыг зааж хоёр дахийг системийн бүрхүүлийн <<startup-file,эхлүүлэх файл>>д орчны хувьсагчийн заалтуудыг нэмснээр хийдэг.

[[login-class]]
===== Нэвтрэх ангилалуудын арга

Энэ арга нь бүрхүүл бүрийн эхлүүлэх файлд тухайн бүрхүүлийн заалтуудыг нэмэхийн оронд локалын нэр болон MIME тэмдэгтийн олонлогуудад хэрэгтэй орчны хувьсагчуудыг боломжит бүрхүүл бүрийн хувьд нэг л удаа заах боломжийг олгодог. <<usr-setup,Хэрэглэгчийн түвшний тохируулгыг>> хэрэглэгч өөрөө хийж болох бөгөөд <<adm-setup,Администраторын түвшний тохируулга>> нь супер хэрэглэгчийн зөвшөөрлүүдийг шаарддаг.

[[usr-setup]]
====== Хэрэглэгчийн түвшний тохируулга

Энд хэрэглэгчийн гэр сан дотор байрлах Latin-1 кодчилолын хувьд хоёр хувьсагчийг нь тохируулж өгсөн [.filename]#.login_conf# файлын хамгийн бага жишээ байна:

[.programlisting]
....
me:\\
	:charset=ISO-8859-1:\\
	:lang=de_DE.ISO8859-1:
....

Энд BIG-5 кодчилолд Уламжлалт Хятад хэлд зориулан хувьсагчуудыг тохируулж байгаа [.filename]#.login_conf# файлын жишээ байна. Зарим програм хангамжууд нь Хятад, Япон болон Солонгос хэлний хувьд локалын хувьсагчуудыг зөвөөр хүндэлдэггүй учраас илүү олон хувьсагчуудыг тохируулсныг эндээс харж болно.

[.programlisting]
....
#Users who do not wish to use monetary units or time formats
#of Taiwan can manually change each variable
me:\\
	:lang=zh_TW.Big5:\\
	:setenv=LC_ALL=zh_TW.Big5:\\
	:setenv=LC_COLLATE=zh_TW.Big5:\\
	:setenv=LC_CTYPE=zh_TW.Big5:\\
	:setenv=LC_MESSAGES=zh_TW.Big5:\\
	:setenv=LC_MONETARY=zh_TW.Big5:\\
	:setenv=LC_NUMERIC=zh_TW.Big5:\\
	:setenv=LC_TIME=zh_TW.Big5:\\
	:charset=big5:\\
	:xmodifiers=""@im=gcin"": #Set gcin as the XIM Input Server
....

Илүү дэлгэрэнгүйг <<adm-setup,Администраторын түвшний тохируулга>> болон man:login.conf[5]-с үзнэ үү.

[[adm-setup]]
===== Администраторын түвшний тохируулга

[.filename]#/etc/login.conf# дахь хэрэглэгчийн нэвтрэх ангилал зөв хэл тохируулсныг шалгана. Эдгээр тохируулгууд [.filename]#/etc/login.conf#-д байгаа эсэхийг шалгаарай:

[.programlisting]
....
language_name:Account Type Description:\\
	:charset=MIME_charset:\\
	:lang=locale_name:\\
	:tc=default:
....

Бидний урдны жишээний адил Latin-1-г сонговол энэ нь иймэрхүү харагдана:

[.programlisting]
....
german|German Users Accounts:\\
	:charset=ISO-8859-1:\\
	:lang=de_DE.ISO8859-1:\\
	:tc=default:
....

Хэрэглэгчийн нэвтрэх ангиллуудыг өөрчлөхөөсөө өмнө дараах тушаалыг ажиллуулж

[source,shell]
....
# cap_mkdb /etc/login.conf
....

шинэ тохиргоог системд харагдуулахаар [.filename]#/etc/login.conf#-д хийнэ.

===== Нэвтрэх ангиллуудыг man:vipw[8] ашиглан солих

Шинэ хэрэглэгчид нэмэхийн тулд `vipw` тушаал ашиглан оруулгыг иймэрхүү болгоно:

[.programlisting]
....
user:password:1111:11:language:0:0:User Name:/home/user:/bin/sh
....

===== Нэвтрэх ангиллуудыг man:adduser[8] ашиглан солих

Шинэ хэрэглэгчид нэмэхийн тулд `adduser` тушаал ашиглан доор дурдсаныг хийнэ:

* [.filename]#/etc/adduser.conf# файлд `defaultclass = language`-г тохируулна. Та энэ тохиолдолд бусад хэлнүүдийн бүх хэрэглэгчдэд зориулан `анхдагч` ангилалыг оруулах хэрэгтэйг санах хэрэгтэй.
* man:adduser[8]-с гарч ирэх асуулт бүрт 
+
[source,shell]
....
Enter login class: default []: 
....
+
асуултад тухайн хэлийг зааж өгөх бас нэг хувилбар байж болно.

* Өөр нэг арга нь нэмэхээр хүсэж байгаа өөр хэлний хэрэглэгч бүрийн хувьд доор дурдсаныг ашиглах явдал юм:
+
[source,shell]
....
# adduser -class language
....

===== Нэвтрэх ангиллуудыг man:pw[8] ашиглан солих

Хэрэв та man:pw[8]-г шинэ хэрэглэгч нэмэхийн тулд ашиглаж байгаа бол үүнийг иймэрхүү маягаар дуудаарай:

[source,shell]
....
# pw useradd user_name -L language
....

[[startup-file]]
===== Бүрхүүлийн эхлүүлэх файл арга

[NOTE]
====
Энэ аргыг зөвлөдөггүй, учир нь сонгосон боломжит бүрхүүл програм бүрийн хувьд өөр тохируулгыг шаарддаг. Оронд нь <<login-class,Нэвтрэх ангиллын аргыг>> ашиглаарай.
====

Локалын нэр болон MIME тэмдэгтийн олонлогийг нэмэхийн тулд доор үзүүлсэн хоёр орчны хувьсагчийг [.filename]#/etc/profile#-д болон/эсвэл бүрхүүлийн эхлүүлэх файл [.filename]#/etc/csh.login#-д зааж өгнө. Бид Герман хэлийг доор жишээ болгон ашиглах болно:

[.filename]#/etc/profile# файлд:

[.programlisting]
....
LANG=de_DE.ISO8859-1; export LANG
MM_CHARSET=ISO-8859-1; export MM_CHARSET
....

Эсвэл [.filename]#/etc/csh.login# файлд:

[.programlisting]
....
setenv LANG de_DE.ISO8859-1
setenv MM_CHARSET ISO-8859-1
....

Өөрөөр та дээрх заавруудыг [.filename]#/usr/shared/skel/dot.profile# файлд (дээрх [.filename]#/etc/profile#-д ашигласантай адил) эсвэл [.filename]#/usr/shared/skel/dot.login# файлд (дээрх [.filename]#/etc/csh.login#-д ашигласантай адил) нэмж болно.

X11-ийн хувьд:

[.filename]#$HOME/.xinitrc# файлд:

[.programlisting]
....
LANG=de_DE.ISO8859-1; export LANG
....

Эсвэл:

[.programlisting]
....
setenv LANG de_DE.ISO8859-1
....

Таны бүрхүүлээс хамаараад (дээр дурдсаныг үзнэ үү).

[[setting-console]]
=== Консол тохируулах

Бүх ганц C chars тэмдэгтийн олонлогуудын хувьд зөв консолын фонтуудыг [.filename]#/etc/rc.conf#-д асуултанд байгаа хэлний хувьд тохируулна:

[.programlisting]
....
font8x16=font_name
font8x14=font_name
font8x8=font_name
....

Эндэх _font_name_-ийг [.filename]#/usr/shared/syscons/fonts# сангаас [.filename]#.fnt# төгсгөлгүйгээр авсан.

Хэрэв шаардлагатай бол keymap болон screenmap-ийг өөрийн ганц C chars тэмдэгтийн олонлогийн хувьд `sysinstall` ашиглан зааж өгнө. sysinstall дотор байхдаа [.guimenuitem]#Configure#-г сонгоод дараа нь [.guimenuitem]#Console#-г сонгоно. Өөрөөр та доор дурдсаныг [.filename]#/etc/rc.conf#-д нэмж болно:

[.programlisting]
....
scrnmap=screenmap_name
keymap=keymap_name
keychange=""fkey_number sequence""
....

Эндэх _screenmap_name_-ийг [.filename]#/usr/shared/syscons/scrnmaps# сангаас [.filename]#.scm# төгсгөлгүйгээр авсан. Зохих оноогдсон фонттой screenmap нь псевдографик талбарт VGA адаптерийн фонтын тэмдэгтийн матриц дээр бит 8-ийг бит 9 уруу өргөтгөхөд ихэвчлэн тойрон гарах арга зам болгон хэрэглэгддэг, өөрөөр хэлбэл хэрэв дэлгэцийн фонт бит 8 багана ашиглаж байвал тэр талбараас үсэгнүүдийг шилжүүлэн гаргахын тулд хэрэглэгддэг.

Хэрэв та [.filename]#/etc/rc.conf#-д moused дэмонг идэвхжүүлэхийг дараах байдлаар тохируулсан бол:

[.programlisting]
....
moused_enable=""YES""
....

хулганы заагчийн мэдээллийг дараагийн хэсгээс шалгаарай.

Анхдагчаар man:syscons[4] драйверийн хулганы заагч нь тэмдэгтийн олонлогийн 0xd0-0xd3 хэсгийг эзэлдэг. Хэрэв таны хэл энэ хэсгийг ашигладаг бол заагчийн хэсгийг үүнээс гадна шилжүүлэх хэрэгтэй. FreeBSD-ийн хувьд тойрон гарах арга замыг идэвхжүүлэхийн тулд дараах мөрийг [.filename]#/etc/rc.conf#-д нэмнэ:

[.programlisting]
....
mousechar_start=3
....

Эндэх _keymap_name_-ийг [.filename]#/usr/shared/syscons/keymaps# сангаас [.filename]#.kbd# төгсгөлгүй авсан. Хэрэв та аль keymap-ийг ашиглах эсэхдээ эргэлзэж байвал man:kbdmap[1]-г ашиглаж дахин ачаалалгүйгээр keymap-уудыг тест хийж болно.

`keychange` нь функцын товчлууруудыг сонгосон терминалын төрөлтэй тааруулахын тулд програмчлахад ихэвчлэн хэрэгтэй байдаг, учир нь функцын товчлуурын дарааллуудыг товчлууруудын оноолтод тодорхойлж болдоггүй.

Бас консолын терминалын зөв төрлийг бүх `ttyv*` оруулгуудын хувьд [.filename]#/etc/ttys# файлд тохируулсан эсэхээ шалгаарай. Одоогийн урьдчилан тодорхойлсон зохицлууд нь:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Тэмдэгтийн Олонлог
| Терминалын Төрөл

|ISO8859-1 эсвэл ISO8859-15
|`cons25l1`

|ISO8859-2
|`cons25l2`

|ISO8859-7
|`cons25l7`

|KOI8-R
|`cons25r`

|KOI8-U
|`cons25u`

|CP437 (VGA default)
|`cons25`

|US-ASCII
|`cons25w`
|===

Өргөн эсвэл олон байт тэмдэгтүүд бүхий хэлнүүдийн хувьд өөрийн [.filename]#/usr/ports/language# сангаас зөв FreeBSD портоо ашиглаарай. Зарим портууд консол маягаар байхад түүнийг систем сериал vtty-үүд шигээр хардаг, ийм учраас та X11 болон псевдо-сериал консолын хувьд хангалттай vtty-үүдийг хадгалж байх шаардлагатай. Өөр хэлүүдийг консолд ашиглахын тулд энд програмуудын хэсэгчилсэн жагсаалт байна:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Хэл
| Байрлал

|Уламжлалт Хятад хэл (BIG-5)
|package:chinese/big5con[]

|Япон хэл
|package:japanese/kon2-16dot[] эсвэл package:japanese/mule-freewnn[]

|Солонгос хэл
|package:korean/han[]
|===

=== X11 тохируулах

X11 нь FreeBSD Төслийн нэг хэсэг биш боловч бид энд FreeBSD хэрэглэгчдэд зориулж зарим мэдээлэл орууллаа. Илүү дэлгэрэнгүйг http://www.x.org/[Xorg вэб хаягаас] эсвэл аль X11 сервер ашиглаж байгаа түүнийхээ вэб хаягаас лавлана уу.

[.filename]#~/.Xresources# файлд та програмуудад зориулсан I18N тохируулгуудыг (өөрөөр хэлбэл фонтууд, цэснүүд, гэх мэт.) тааруулж өгч болно.

==== Фонтуудыг үзүүлэх

Xorg сервер (package:x11-servers/xorg-server[]) суулгаад дараа нь хэлний TrueType(R) фонтуудыг суулгана. Зөв локалыг тохируулах нь танд цэснүүдийг сонгосон хэлээрээ харах зэрэг боломжийг олгоно.

==== Англи биш тэмдэгтүүдийг оруулах нь

X11 оруулах арга (XIM) нь бүх X11 клиентүүдэд зориулсан шинэ стандарт юм. Бүх X11 програмууд нь XIM оруулах серверүүдээс оролт авдаг XIM клиентүүд маягаар бичигдэх ёстой. Өөр өөр хэлнүүдэд зориулагдсан хэд хэдэн XIM серверүүд байдаг.

=== Хэвлэгч тохируулах

Зарим ганц C chars тэмдэгтийн олонлогууд нь ихэвчлэн хэвлэгчүүд дотор хатуугаар бичигдсэн байдаг. Өргөн эсвэл олон байт тэмдэгтийн олонлогууд нь тусгай тохируулга шаарддаг бөгөөд бид apsfilter програмыг хэрэглэхийг зөвлөдөг. Та бас PostScript(R) эсвэл PDF хэлбэрүүд уруу тухайн хэлний хөрвүүлэгчдийг ашиглан баримтыг хөрвүүлж болох юм.

=== Цөм ба файлын системүүд

FreeBSD-ийн хурдан файлын систем (FFS) нь 8-бит цэвэр учир үүнийг ямар ч ганц C chars тэмдэгтийн олонлогтой цуг ашиглаж болно (man:multibyte[3]-г үзнэ үү), гэхдээ тэмдэгтийн олонлогийн нэр файлын системд хадгалагддаггүй; өөрөөр хэлбэл энэ нь түүхий 8-бит бөгөөд кодчилолын дарааллын талаар юу ч мэддэггүй. Албан ёсоор FFS нь өргөн эсвэл олон байт тэмдэгтийн олонлогуудын аль ч хэлбэрийг дэмждэггүй. Гэхдээ зарим өргөн эсвэл олон байт тэмдэгтийн олонлогууд нь FFS-д ийм дэмжлэгийг идэвхжүүлэхэд зориулсан бие биеэсээ ангид засваруудтай байдаг. Тэдгээр нь цорын ганц ийш тийш хөрвүүлэх боломжгүй шийдлүүд буюу hack бөгөөд бид тэдгээрийг эх модонд оруулахгүй гэж шийдэцгээсэн юм. Тохирох хэлнүүдийн вэб хуудаснуудаас илүү дэлгэрэнгүй мэдээлэл болон засвар файлуудын талаар лавлана уу.

FreeBSD MS-DOS(R) файлын систем нь MS-DOS(R), Юникод тэмдэгтийн олонлогууд болон FreeBSD-ийн сонгосон файлын системийн тэмдэгтийн олонлогуудын хооронд хөрвүүлэх тохируулж болох боломж бүхий байдаг. Дэлгэрэнгүйг man:mount_msdosfs[8]-с үзнэ үү.

[[l10n-compiling]]
== I18N програмуудыг эмхэтгэх

FreeBSD-ийн олон портууд I18N дэмжлэгтэйгээр хөрвүүлэгдсэн байдаг. Тэдгээрийн зарим нь портын нэрэндээ -I18N гэж тэмдэглэгдсэн байдаг. Эдгээр болон бусад олон програмууд I18N-д зориулагдсан дэмжлэгтэйгээр бүтээгдсэн байдаг бөгөөд тусгай хэлэлцүүлэг шаардлагагүй юм.

Гэхдээ MySQL зэрэг зарим програмууд тусгайлсан charset бүхий байхаар тохируулагдсан [.filename]#Makefile# файлтай байх шаардлагатай. Үүнийг ихэвчлэн [.filename]#Makefile#-д эсвэл эхэд байх configure програмд утга дамжуулан хийдэг.

[[lang-setup]]
== FreeBSD-г өөр хэлнүүд уруу локалчлах

[[ru-localize]]
=== Орос хэл (KOI8-R Кодчилол)

KOI8-R кодчилолын талаар дэлгэрэнгүй мэдээллийг http://koi8.pp.ru/[KOI8-R Лавлахууд (Russian Net Character Set)]-с үзнэ үү.

==== Локал Тохируулах

Дараах мөрүүдийг өөрийн [.filename]#~/.login_conf# файлд нэмнэ:

[.programlisting]
....
me:My Account:\\
	:charset=KOI8-R:\\
	:lang=ru_RU.KOI8-R:
....

Энэ бүлгийн өмнөхөөс <<setting-locale,локал>> тохируулах жишээнүүдийг үзнэ үү.

==== Консол Тохируулга

* Дараах мөрийг өөрийн [.filename]#/etc/rc.conf# файлд нэмнэ:
+
[.programlisting]
....
mousechar_start=3
....

* Мөн дараах тохируулгуудыг [.filename]#/etc/rc.conf#-д ашиглана:
+
[.programlisting]
....
keymap=""ru.utf-8""
scrnmap=""utf-82cp866""
font8x16=""cp866b-8x16""
font8x14=""cp866-8x14""
font8x8=""cp866-8x8""
....

* [.filename]#/etc/ttys# файл дахь `ttyv*` оруулга болгоны хувьд `cons25r`-ийг терминалын төрөлд ашиглана.

Энэ бүлгийн өмнөхөөс <<setting-console,консол>> тохируулах жишээнүүдийг үзнэ үү.

==== Хэвлэгчийн Тохируулга

Орос тэмдэгтүүдтэй ихэнх хэвлэгчид CP866 гэсэн тоног төхөөрөмжийн код хуудастай ирдэг бөгөөд KOI8-R-с CP866 уруу хөрвүүлэхийн тулд тусгай гаралтын шүүгч хэрэгтэй болдог. Ийм шүүгч анхдагчаар [.filename]#/usr/libexec/lpr/ru/koi2alt# гэж суугддаг. Орос хэвлэгчийн [.filename]#/etc/printcap# оруулга иймэрхүү харагдах ёстой:

[.programlisting]
....
lp|Russian local line printer:\\
	:sh:of=/usr/libexec/lpr/ru/koi2alt:\\
	:lp=/dev/lpt0:sd=/var/spool/output/lpd:lf=/var/log/lpd-errs:
....

Дэлгэрэнгүй тайлбарын талаар man:printcap[5]-с үзнэ үү.

==== MS-DOS(R) FS болон Орос файлын нэрс

Дараах жишээ man:fstab[5] оруулга нь холбогдсон MS-DOS(R) файлын системүүд дээр Орос файлын нэрийн дэмжлэгийг идэвхжүүлдэг:

[.programlisting]
....
/dev/ad0s2      /dos/c  msdos   rw,-Wkoi2dos,-Lru_RU.KOI8-R 0 0
....

`-L` тохируулга ашиглагдсан локалын нэрийг сонгодог бөгөөд `-W` нь тэмдэгтийн хөрвүүлэлтийн хүснэгтийг заадаг. `-W` тохируулгыг ашиглахын тулд [.filename]#/usr#-г MS-DOS(R) хуваалтаас өмнө холбох хэрэгтэй, учир нь хөрвүүлэлтийн хүснэгтүүд [.filename]#/usr/libdata/msdosfs#-д байрладаг. Дэлгэрэнгүй мэдээллийг man:mount_msdosfs[8] гарын авлагын хуудаснаас үзнэ үү.

==== X11 тохируулга

. Эхлээд <<setting-locale,X биш локалын тохируулгыг>> тайлбарласнаар хийнэ.
. Хэрэв та Xorg-г ашиглаж байгаа бол package:x11-fonts/xorg-fonts-cyrillic[] багцыг суулгана.
+ 
Өөрийн [.filename]#/etc/X11/xorg.conf# файлын `""Files""` хэсгийг шалгаарай. Дараах мөр аль ч `FontPath` оруулгуудаас _өмнө_ нэмэгдсэн байх шаардлагатай:
+
[.programlisting]
....
FontPath   ""/usr/local/lib/X11/fonts/cyrillic""
....
+
[NOTE]
====
Өөр илүү олон кирилл фонтуудыг авахыг хүсвэл портуудаас үзнэ үү.
====

. Орос гарыг идэвхжүүлэхийн тулд өөрийн [.filename]#xorg.conf# файлын `""Keyboard""` хэсэгт доор дурдсаныг нэмээрэй:
+
[.programlisting]
....
Option ""XkbLayout""   ""us,ru""
Option ""XkbOptions""  ""grp:toggle""
....
+ 
Мөн `XkbDisable`-г хаасан (тайлбар болгосон) эсэхийг тэндээс шалгаарай.
+ 
`grp:toggle`-н хувьд RUS/LAT шилжүүлэгч kbd:[Right Alt] болох бөгөөд `grp:ctrl_shift_toggle` шилжүүлэгчийн хувьд kbd:[Ctrl+Shift] болно. `grp:caps_toggle`-н хувьд RUS/LAT шилжүүлэгч kbd:[CapsLock] байна. Хуучин kbd:[CapsLock] функцын хувьд kbd:[Shift+CapsLock] (зөвхөн LAT горимд) байсаар байна. `grp:caps_toggle` нь Xorg дээр тодорхойгүй шалтгааны улмаас ажилладаггүй.
+ 
Хэрэв та өөрийн гар дээрээ ""Windows(R)"" товчлууруудтай бол, зарим үсгэн товчлуурууд нь RUS горимд буруугаар тааруулагддагийг анзаарсан байх, өөрийн [.filename]#xorg.conf# файлдаа дараах мөрийг нэмээрэй:
+
[.programlisting]
....
Option ""XkbVariant"" "",winkeys""
....
+
[NOTE]
====
Орос XKB гар нь локалчлал хийгдээгүй програмуудтай ажиллахгүй байж болох юм.
====

[NOTE]
====
Хамгийн багаар локалчлагдсан програмууд `XtSetLanguageProc (NULL, NULL, NULL);` функцыг програмын эхэнд дуудах ёстой.

X11 програмуудыг локалчлах талаар дэлгэрэнгүй заавруудыг http://koi8.pp.ru/xwin.html[X Цонхны KOI8-R] хаягаас үзнэ үү.
====

=== Тайваньд зориулсан уламжлалт Хятад хэлний локалчлал

FreeBSD-Тайвань Төсөл олон Хятад портуудыг ашиглан FreeBSD-д зориулсан Хятад HOWTO-г http://netlab.cse.yzu.edu.tw/\\~statue/freebsd/zh-tut/[http://netlab.cse.yzu.edu.tw/~statue/freebsd/zh-tut/] дээр байрлуулсан байдаг. `FreeBSD Хятад HOWTO`-н одоогийн засварлагч нь Чуан-Шинг Шен mailto:statue@freebsd.sinica.edu.tw[statue@freebsd.sinica.edu.tw] юм. 

Чуан-Шинг Шен mailto:statue@freebsd.sinica.edu.tw[statue@freebsd.sinica.edu.tw] нь FreeBSD-Тайваний `zh-L10N-tut` ашиглан http://netlab.cse.yzu.edu.tw/\\~statue/cfc/[Хятад FreeBSD Цуглуулга (CFC)] үүсгэсэн байгаа. Багцууд болон скрипт файлууд link:ftp://freebsd.csie.nctu.edu.tw/pub/taiwan/CFC/[ftp://freebsd.csie.nctu.edu.tw/pub/taiwan/CFC/] дээр байгаа болно.

=== Герман хэлний локалчлал(бүх ISO 8859-1 хэлнүүдэд зориулсан)

Славен Резич mailto:eserte@cs.tu-berlin.de[eserte@cs.tu-berlin.de] нь FreeBSD машин дээр umlaut буюу Герман хэлний авиа өөрчлөгддөгийг тэмдэглэдэг хоёр цэгийг хэрхэн ашиглах талаар заавар бичсэн байгаа. Энэ заавар нь Герман хэл дээр бичигдсэн бөгөөд http://user.cs.tu-berlin.de/\\~eserte/FreeBSD/doc/umlaute/umlaute.html[http://user.cs.tu-berlin.de/~eserte/FreeBSD/doc/umlaute/umlaute.html] дээр байгаа болно.

=== Грек хэлний локалчлал

Никос Кокалис mailto:nickkokkalis@gmail.com[nickkokkalis@gmail.com] нь FreeBSD дээрх Грек хэлний дэмжлэгийн талаар бүрэн нийтлэл бичсэн байгаа. Энэ нь FreeBSD-ийн албан ёсны Грек баримтжуулалтын хэсэг болон https://www.FreeBSD.org/doc/el/articles/greek-language-support/[http://www.freebsd.org/doc/el/articles/greek-language-support/] хаягт орсон байдаг. Энэ нь _зөвхөн_ Грек хэл дээр юм.

=== Япон болон Солонгос хэлний локалчлал

Япон хэлний хувьд http://www.jp.FreeBSD.org/[http://www.jp.FreeBSD.org/]-д хандана уу, Солонгос хэлний хувьд http://www.kr.FreeBSD.org/[http://www.kr.FreeBSD.org/]-д хандана уу.

=== Англи биш FreeBSD баримтжуулалт

FreeBSD-ийн зарим хувь нэмэр оруулагчид FreeBSD-ийн баримтжуулалтын зарим хэсгийг орчуулсан байгаа. Тэдгээрийг link:https://www.FreeBSD.org/[эх сайт] дээрх холбоосуудаас эсвэл [.filename]#/usr/shared/doc# сангаас үзэж болох юм.
",12483,True,2641.310780559665,median
":toc: macro
toc::[]
:idprefix:
:idseparator: -
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:important-caption: :heavy_exclamation_mark:
:caution-caption: :fire:
:warning-caption: :warning:
endif::[]

= devon4j adding Custom Functionality

Now we have a fully functional blank project. All we have to do now is to create the components and services which will compose our application.

First, we are going to develop the views of the app through its components, then we will create the services with the logic, security and back-end connection.


== Creating Components

[NOTE]
====
You have already learned about creating Components in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#create-a-new-component[here]. +
You can go back and read that section again to refresh your memory.
====

Our app is going to consist of 3 main views:

* `Login`
* `Register`
* `ViewQueue`

To navigate between these views/components, we are going to implement routes using the Angular Router.

To see our progress, move to the root folder of the `angular` project and run `ng serve -o` again. This will recompile and publish our client app to http://localhost:4200. Angular will keep watching for changes, so whenever we modify the code, the app will automatically reload.

=== Root Component

`app.component.ts` inside `angular/src/app` will be our root component, so we don't have to create a new file yet. We are going to add elements to the root component that will be common no matter what view will be displayed.

[NOTE]
====
You have already learned about the Root Component in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#root-component[here]. +
You can go back and read that section again to refresh your memory.
====

This applies to the header element which will be on top of the window and on top of all other components. If you want, you can read more about https://teradata.github.io/covalent/#/layouts[Covalent layouts], which we are going to use a lot from now on, for every view component.

[NOTE]
====
You have already learned about Covalent Layouts in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#teradata-covalent-layouts[here]. +
You can go back and read that section again to refresh your memory.
====

We don't really need anything more than a header, so we are going to use the simplest layout for this purpose; the *nav view*.

In order to be able to use Covalent and Angular Material we are going to create a core module, which we will import into every other module where we want to use Covalent and Angular Material. First, we create a folder called `shared` in the `angular/src/app` directory. Inside there we are going to create a file called `core.module.ts` and will fill it with the following content:

[source, typescript]
----
import { NgModule } from '@angular/core';
import { RouterModule } from '@angular/router';
import { CommonModule } from '@angular/common';
import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import {
  MatAutocompleteModule,
  MatButtonModule,
  MatButtonToggleModule,
  MatCardModule,
  MatCheckboxModule,
  MatChipsModule,
  MatDatepickerModule,
  MatDialogModule,
  MatExpansionModule,
  MatGridListModule,
  MatIconModule,
  MatInputModule,
  MatListModule,
  MatMenuModule,
  MatNativeDateModule,
  MatPaginatorModule,
  MatProgressBarModule,
  MatProgressSpinnerModule,
  MatRadioModule,
  MatRippleModule,
  MatSelectModule,
  MatSidenavModule,
  MatSliderModule,
  MatSlideToggleModule,
  MatSnackBarModule,
  MatSortModule,
  MatTableModule,
  MatTabsModule,
  MatToolbarModule,
  MatTooltipModule,
} from '@angular/material';
import { CdkTableModule } from '@angular/cdk/table';
import {
  CovalentChipsModule,
  CovalentLayoutModule,
  CovalentExpansionPanelModule,
  CovalentDataTableModule,
  CovalentPagingModule,
  CovalentDialogsModule,
  CovalentLoadingModule,
  CovalentMediaModule,
  CovalentNotificationsModule,
  CovalentCommonModule,
} from '@covalent/core';

@NgModule({
  imports: [
    RouterModule,
    BrowserAnimationsModule,
    MatCardModule,
    MatButtonModule,
    MatIconModule,
    CovalentMediaModule,
    CovalentLayoutModule,
    CdkTableModule,
  ],
  exports: [
    CommonModule,
    CovalentChipsModule,
    CovalentLayoutModule,
    CovalentExpansionPanelModule,
    CovalentDataTableModule,
    CovalentPagingModule,
    CovalentDialogsModule,
    CovalentLoadingModule,
    CovalentMediaModule,
    CovalentNotificationsModule,
    CovalentCommonModule,
    CdkTableModule,
    MatAutocompleteModule,
    MatButtonModule,
    MatButtonToggleModule,
    MatCardModule,
    MatCheckboxModule,
    MatChipsModule,
    MatDatepickerModule,
    MatDialogModule,
    MatExpansionModule,
    MatGridListModule,
    MatIconModule,
    MatInputModule,
    MatListModule,
    MatMenuModule,
    MatNativeDateModule,
    MatPaginatorModule,
    MatProgressBarModule,
    MatProgressSpinnerModule,
    MatRadioModule,
    MatRippleModule,
    MatSelectModule,
    MatSidenavModule,
    MatSliderModule,
    MatSlideToggleModule,
    MatSnackBarModule,
    MatSortModule,
    MatTableModule,
    MatTabsModule,
    MatToolbarModule,
    MatTooltipModule,
    HttpClientModule,
  ],
  declarations: [],
  providers: [
    HttpClientModule
  ],
})
export class CoreModule {}
----

[NOTE]
====
This `CoreModule` has almost every module of the different components for *Angular Material* and *Covalent Teradata*. If you decide to use a component that is not included yet, you need to add the corresponding module here.
====

Remember that we need to import this `CoreModule` module into the `AppModule` and inside every module of the different components that use *Angular Material* and *Covalent Teradata*. If a component does not have a module, it will be imported in the `AppModule` and hence automatically have the `CoreModule`. Our `app.module.ts` should have the following content:

[source, typescript]
----
import { BrowserModule } from '@angular/platform-browser';
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';

// Application components and services
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { CoreModule } from './shared/core.module';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    AppRoutingModule,
    CoreModule,
  ],
  providers: [
  ],
  bootstrap: [AppComponent],
  schemas: [ CUSTOM_ELEMENTS_SCHEMA ]
})
export class AppModule { }
----
[NOTE]
====
Even if we setup module correctly the HTML file can give us this red flag: ""If `td-layout` is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the `@NgModule.schemas` of this component to suppress this message.""
To solve this we add ""schemas: [ CUSTOM_ELEMENTS_SCHEMA ]"" inside the `@NgModule` of all the affected modules.
====

[NOTE]
====
Remember this step because you will have to repeat it for every other component from Teradata you use in your app.
====

Now we can use this layout, so let's implement it in `app.component.html`. Use the following code:

[source, html]
----
<td-layout-nav>             <!-- Layout tag-->
  <div td-toolbar-content>
    Jump The Queue          <!-- Header container-->
  </div>
  <h1>
    app works!              <!-- Main content-->
  </h1>
</td-layout-nav>
----

[NOTE]
====
You have already learned about Toolbars in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#toolbars[here]. +
You can go back and read that section again to refresh your memory.
====

[NOTE]
====
You have already learned about Toolbars in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#toolbars[here]. +
You can go back and read that section again to refresh your memory.
====

Once this is done, our app should have a header and ""app works!"" should appear in the body of the page:

image::images/devon4ng/3.BuildYourOwn/root_header.jpg[Root Header, 250]

To go a step further, we have to modify the body of the root component because it should be the *output of the router*. Now it's time to prepare the routing system.

First, we need to create a component to show as default which will be our access view. We will modify it later. Stop `ng serve` and run:

```
ng generate component form-login
```

It will add a folder to our project with all the files needed for a component. Now we can move on to the router task again. Run `ng serve` again to continue the development.

Let's create a module that navigates between components when the Router checks for routes. The file `app-routing.module.ts` was created automatically when we chose to include Angular Routing during project creation and we only need to modify it now:

[source, typescript]
----
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { FormLoginComponent } from './form-login/form-login.component';

const appRoutes: Routes = [
  { path: 'FormLogin', component: FormLoginComponent},        // Redirect if url path is /FormLogin.
  { path: '**', redirectTo: '/FormLogin', pathMatch: 'full' } // Redirect if url path do not match any other route.
];

@NgModule({
  imports: [
    RouterModule.forRoot(
      appRoutes,
      { enableTracing: true }, // <-- debugging purposes only
    ),
  ],
  exports: [RouterModule],
})
export class AppRoutingModule {}
----

[NOTE]
====
You have already learned about Routing in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#routing[here]. +
You can go back and read that section again to refresh your memory.
====

Finally, we remove the `<h1>app works!</h1>` from `app.component.html` and replace it with a `<router-outlet></router-outlet>` tag. The final result of our root component will look like this:

image::images/devon4ng/3.BuildYourOwn/root_router.jpg[Root Router, 250]

As you can see, now the body content is the HTML of `FormLoginComponent`. This is because we told the Router to redirect to login form when the path is `/FormLogin`, but also, redirect to it by default if any of the other routes match the given path.

For now we are going to leave the header like this. In the future we will separate it into another component inside a layout folder.

=== `LoginForm` Component

As we have already created this component from the section before, let's move on to building the template of the login view.

First, we need to add the Covalent Layout and the card to the file `form-login.component.html`:

[source, html]
----
<td-layout>
  <mat-card>
    <mat-card-title>Login</mat-card-title>
  </mat-card>
</td-layout>
----

This will add a gray background to the view and a card on top of it with the title ""Login"" now that we have the basic structure of the view.

Now we are going to add this image:

image::images/devon4ng/3.BuildYourOwn/jumptheq.png[JumpTheQueue Logo Image, 250]

In order to have it available, save it in the following path of the project: `angular/src/assets/images/` and name it `jumptheq.png`.

The final code with the form added will look like this:

[source, html]
----
<td-layout>
  <mat-card>
    <img mat-card-image src=""assets/images/jumptheq.png"">
  </mat-card>
</td-layout>
----

This code will give us as a result similar to this:

image::images/devon4ng/3.BuildYourOwn/formlogin.png[Form Login, 250]

This is going to be the container for the login. +
Now we will continue with the second component: Login.

=== Login Component

Our first step will be to create the component in the exact same way we created the `FormLogin` component but this time we are going to generate it in a new folder called components inside `formlogin`. Putting every child component inside that folder will allow us to keep a good and clear structure. In order to do this, we use the command:

```
ng generate component form-login/components/login
```

After _Angular/CLI_ has finished generating the component, we have to create two modules, one for the form-login and one for the login:

1.- We create a new file called `login-module.ts` in the login root:

[source, typescript]
----
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { CommonModule } from '@angular/common';
import { CoreModule } from 'src/app/shared/core.module';
import { LoginComponent } from './login.component';

@NgModule({
  imports: [CommonModule, CoreModule],
  providers: [],
  declarations: [LoginComponent],
  exports: [LoginComponent],
  schemas: [ CUSTOM_ELEMENTS_SCHEMA ]
})
export class LoginModule {}
----

2.- We create a new file called `form-login-module.ts` in the form-login root:

[source, typescript]
----
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormLoginComponent } from './form-login.component';
import { CoreModule } from '../shared/core.module';
import { LoginModule } from './components/login/login-module';

@NgModule({
  imports: [CommonModule, CoreModule, LoginModule],
  providers: [],
  declarations: [FormLoginComponent],
  exports: [FormLoginComponent],
  schemas: [ CUSTOM_ELEMENTS_SCHEMA ]
})
export class FormLoginModule {}
----

As you can see, the `LoginModule` is already added to the `FormLoginModule`. Once this is done, we need to remove the `FormLoginComponent` and the `LoginComponent` from the `declarations` since they are already declared in their own modules. Then add the `FormLoginModule`. This will be done inside `AppModule`:

[source, typescript]
----
...
import { FormLoginModule } from './form-login/form-login-module';
...
  declarations: [
    AppComponent,
  ]

  imports: [
    BrowserModule,
    FormLoginModule,
    CoreModule,
    AppRoutingModule
  ]
...
----

[NOTE]
====
This is done so the `form-login` (container/wrapper) and the `login` stay separated allowing us to reuse the login without having the card around in other views.
====

After this, we modify the `login.component.html` and add the form: 

[source, typescript]
----
<form #loginForm=""ngForm"" layout-padding>
    <div layout=""row"" flex>
        <mat-form-field flex>
                <input matInput placeholder=""Email"" ngModel email name=""username"" required>
        </mat-form-field>
    </div>
    <div layout=""row"" flex>
        <mat-form-field flex>
            <input matInput placeholder=""Password"" ngModel name=""password"" type=""password"" required>
        </mat-form-field>
    </div>
    <div layout=""row"" flex>
    </div>
    <div layout=""row"" flex layout-margin>
        <div layout=""column"" flex>
            <button mat-raised-button [disabled]=""!loginForm.form.valid"">Login</button>
        </div>
        <div layout=""column"" flex>
            <button mat-raised-button color=""primary"">Register</button>
        </div>
    </div>
</form>
----

[NOTE]
====
You have already learned about Forms in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#forms[here]. +
You can go back and read that section again to refresh your memory.
====

This form contains two input containers from Material. The containers enclose the input with the properties listed above.

We also need to add a button to send the information and redirect to the `QueueViewer` or show an error if something went wrong in the process. But for the moment, as we neither have another component nor the `auth` service yet, we will implement the button visually, as well as the validator to disable it if the form is not correct. We will tackle the on-click-event later.

As a last step we will add this component to the `form-login-component.html`:

[source, html]
----
<td-layout>
    <mat-card>
        <img mat-card-image src=""assets/images/jumptheq.png"">
        <app-login></app-login>
    </mat-card>
</td-layout>
----

Now you should see something like this:

image::images/devon4ng/3.BuildYourOwn/login.png[JumpTheQueue Login Screen, 250]

With two components already created, we need to use the router to navigate between them. Following the application flow of events, we are going to add a _navigate_ function to the register button. When we press it, we will be redirected to our future register component.

=== Register Component

First, we are going to generate the register component via:

```
ng generate component register`
```

This will create our component so we can start working on it. Turning back to `login.component.html` we have to modify these lines of code:

[source, html]
----
<form (ngSubmit)=""submitLogin()"" #loginForm=""ngForm"" layout-padding>
... 
<button mat-raised-button type=""submit"" [disabled]=""!loginForm.form.valid"">Login</button>
...       
<button mat-raised-button (click)=""onRegisterClick()"" color=""primary"">Register</button>
----

Two events were added. First, when we submit the form, the method `submitLogin()` is going to be called. Second, when the user clicks the button `(click)` will send an event to the function `onRegisterClick()`. This function should be inside `login.component.ts` which is going to be created now:

[source, typescript]
----
  ...
  import { Router } from '@angular/router';
  ...
  constructor(private router: Router) { }
  ...
  onRegisterClick(): void {
    this.router.navigate(['Register']);
  }

  submitLogin(): void {
  }
----

We need to inject an instance of the Router object and declare it with the name _router_ in order to use it in the code, as we did with `onRegisterClick()`. Doing this will use the navigate function and redirect to the next view. In our case, it will redirect using the route we are going to define in `app.routing.module.ts`:

[source, typescript]
----
...
import { RegisterComponent } from './register/register.component';
...
const appRoutes: Routes = [
  { path: 'FormLogin', component: FormLoginComponent},          // Redirect if url path is /FormLogin.
  { path: 'Register', component: RegisterComponent},            // Redirect if url path is /Register.
  { path: '**', redirectTo: '/FormLogin', pathMatch: 'full' }   // Redirect if url path do not match any other route.
];
...
----

[NOTE]
====
You have already learned about Dependency Injection in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#dependency-injection[here]. +
You can go back and read that section again to refresh your memory.
====

Now we are going to imitate the `login` to shape our `register.component.html`:

[source, html]
----
<form layout-padding (ngSubmit)=""submitRegister()"" #registerForm=""ngForm"">
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Email"" ngModel email name=""username"" required>
      </mat-form-field>
  </div>
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Password"" ngModel name=""password"" type=""password"" required>
      </mat-form-field>
  </div>
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Name"" ngModel name=""name"" required>
      </mat-form-field>
  </div>
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Phone Number"" ngModel name=""phoneNumber"" required>
      </mat-form-field>
  </div>
  <div layout-xs=""row"" flex>
      <div layout=""column"" flex>
        <mat-checkbox name=""acceptedTerms"" ngModel required>Accept Terms And conditions</mat-checkbox>
      </div>
  </div>
  <div layout-xs=""row"" flex>
      <div layout=""column"" flex>
        <mat-checkbox name=""acceptedCommercial"" ngModel required>I want to receive notifications</mat-checkbox>
      </div>
  </div>
  <div layout=""row"" flex>
  </div>
  <div layout=""row"" flex>
      <div layout=""column"" flex=""10"">
        </div>
      <div layout=""column"" flex>
          <button mat-raised-button type=""submit"" [disabled]=""!registerForm.form.valid"">Register</button>
      </div>
      <div layout=""column"" flex=""10"">
      </div>
  </div>
</form>
----

Now that we have a minimum of navigation flow inside our application, we are going to generate our first service using the command:

```
ng generate service register/services/register
```

This will create a folder ""services"" inside ""register"" and create the service itself. Services are where we keep the logic that connects to our database and fetches data which is going to be used by our `component.ts`.

In order to use the service, we are going to create some interface models. Let's create a folder called `backendModels` inside ""shared"" and inside this folder a file called `interfaces.ts` in which we are going to add the model interfaces that will match our back-end:

[source, typescript]
----
export class Visitor {
    id?: number;
    username: string;
    name: string;
    password: string;
    phoneNumber: string;
    acceptedCommercial: boolean;
    acceptedTerms: boolean;
    userType: boolean;
}
export class VisitorArray {
    content: Visitor[];
}
----

[NOTE]
====
You have already learned about creating new services in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#create-a-new-service[here]. +
You can go back and read that section again to refresh your memory.
====

If we take a closer look, we can see that id has a `?` behind it. This indicates that the id is optional.

[NOTE]
====
At this point we are going to assume that you have finished the https://github.com/devonfw/jump-the-queue/wiki/build-devon4j-application[devon4j] part of this tutorial, or have at least downloaded the project and have the back end running locally on http://localhost:8081.
====

After doing this, we are going to add an environment variable with our base-URL for the REST services. This way we won't have to change every URL when we switch to production. Inside `environments/environment.ts` we add:

[source, typescript]
----
export const environment: {production: boolean, baseUrlRestServices: string} = {
  production: false,
  baseUrlRestServices: 'http://localhost:8081/jumpthequeue/services/rest'
};
----

Now in the service, we are going to add a `registerVisitor` method.

To call the server in this method we are going to inject the Angular `HttpClient` class from `@angular/common/http`. This class is the standard used by Angular to perform HTTP calls. The register call demands a `Visitor` model which we created in the `interfaces` file. We are going to build a POST call and send the information to the proper URL of the server service. The call will return an observable:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Visitor} from 'src/app/shared/backendModels/interfaces';
import { Observable } from 'rxjs';
import { environment } from 'src/environments/environment';

@Injectable({
  providedIn: 'root'
})
export class RegisterService {

  private baseUrl = environment.baseUrlRestServices;

  constructor(private http: HttpClient) { }

  registerVisitor(visitor: Visitor): Observable<Visitor> {
    return this.http.post<Visitor>(`${this.baseUrl}` + '/visitormanagement/v1/visitor', visitor);
  }
}
----

This method will send our model to the back-end and return an Observable that we will use on the `component.ts`.

[NOTE]
====
You have already learned about Observables and RxJs in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#server-communication[here]. +
You can go back and read that section again to refresh your memory.
====

Now we are going to modify `register.component.ts` to call this service:

[source, typescript]
----
import { Component, OnInit } from '@angular/core';
import { RegisterService } from './services/register.service';
import { Visitor } from '../shared/backendModels/interfaces';
import { Router } from '@angular/router';
import { MatSnackBar } from '@angular/material/snack-bar';

@Component({
  selector: 'app-register',
  templateUrl: './register.component.html',
  styleUrls: ['./register.component.scss']
})
export class RegisterComponent implements OnInit {

  constructor(private registerService: RegisterService, private router: Router, public snackBar: MatSnackBar) { }

  submitRegister(formValue): void {
    const visitor: Visitor = new Visitor();
    visitor.username = formValue.username;
    visitor.name = formValue.name;
    visitor.phoneNumber = formValue.phoneNumber;
    visitor.password = formValue.password;
    visitor.acceptedCommercial = formValue.acceptedCommercial;
    visitor.acceptedTerms = formValue.acceptedTerms;
    visitor.userType = false;

    this.registerService.registerVisitor(visitor).subscribe(
      (visitorResult: Visitor) => console.log(JSON.stringify(visitorResult)), // When call is received
      (err) =>  this.snackBar.open(err.error.message, 'OK', {
        duration: 5000,
      }), // When theres an error
    );
  }

  ngOnInit() {
  }
}
----

In this file we injected `RegisterService` and `Router` to use them. Then, inside the method `submitRegister`, we created a visitor that we are going to pass to the service. We called the service method `registerVisitor`, we passed the visitor and we subscribed to the `Observable<Visitor>`, which we returned from the service. This subscription allows us to control three things:

. What to do when the data is received.

. What to do when there's an error.

. What to do when the call is complete.

Finally, we modify the `register.component.html` to send the form values to the method:

[source, html]
----
...
<form layout-padding (ngSubmit)=""submitRegister(registerForm.form.value)"" #registerForm=""ngForm"">
...
----

image::images/devon4ng/3.BuildYourOwn/register.png[Register Page, 250]

Using the method and taking a look at the browser console, we should see the visitor model being returned.

== Creating Services

Now that we registered a `Visitor`, it's time to create 3 important services:

- AuthService
- AuthGuardService
- LoginService

The `AuthService` will be the one that contains the login info, the `AuthGuardService` will check if a user is authorized to use a component (via the `canActivate` method), and the `LoginService` will be used to fill the `AuthService`.

[NOTE]
====
To keep this tutorial simple, we are going to perform the password check client side. *THIS IS NOT CORRECT!* Usually, you would send the username and password to the back-end, check that the values are correct, and create a corresponding token which you would pass in the header and use it inside the `AuthService` -- checking with some interceptors that the token is both in the `AuthService` and in the request.
====

=== Login, Auth and AuthGuard Services

We are going to create the 3 services via `ng generate service <path>`:

. `LoginService` via: +
`ng generate service form-login/components/login/services/login`

. `Auth` service via: +
`ng generate service core/authentication/auth`

. `AuthGuard` service via: +
`ng generate service core/authentication/auth-guard`

After generating the services, we are going to start modifying the interfaces. Inside `angular/src/app/shared/backendModels/interfaces` we are going to add `Role`, `FilterVisitor`, `Pageable` and a `Sort` interface:

[source, typescript]
----
...
export class FilterVisitor {
    pageable: Pageable;
    username?: string;
    password?: string;
}

export class Pageable {
    pageSize: number;
    pageNumber: number;
    sort: Sort[];
}

export class Sort {
    property: string;
    direction: string;
}

export class Role {
    name: string;
    permission: number;
}
----

[NOTE]
====
As you can see, we added a `Pageable`, since a lot of the search methods in the back-end are using `SearchCriterias`. These need pageables which specify a `paseSize` and `pageNumber`. Also, we can see that in this case `FilterVisitor` uses a pageable and adds parameters as a filter (`username` and `password`), which are optional.
====

Then we are going to create a `config.ts` file inside the root (`angular/app`). We are going to use that file to set up default config variables, for example: role names with their permission number, default pagination settings etc. For now we are just adding the roles:

[source, typescript]
----
export const config: any = {
    roles: [
        { name: 'VISITOR', permission: 0 },
        { name: 'BOSS', permission: 1 },
    ],
};
----

After that, we are going to modify the `auth.service.ts`:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { find } from 'lodash';
import { Role } from 'src/app/shared/backendModels/interfaces';
import { config } from 'src/app/config';

@Injectable({
  providedIn: 'root'
})
export class AuthService {
  private logged = false;
  private user = '';
  private userId = 0;
  private currentRole = 'NONE';
  private token: string;

  public isLogged(): boolean {
    return this.logged;
  }

  public setLogged(login: boolean): void {
    this.logged = login;
  }

  public getUser(): string {
    return this.user;
  }

  public setUser(username: string): void {
    this.user = username;
  }

  public getUserId(): number {
    return this.userId;
  }

  public setUserId(userId: number): void {
    this.userId = userId;
  }

  public getToken(): string {
    return this.token;
  }

  public setToken(token: string): void {
    this.token = token;
  }

  public setRole(role: string): void {
    this.currentRole = role;
  }

  public getPermission(roleName: string): number {
    const role: Role = <Role>find(config.roles, { name: roleName });
    return role.permission;
  }

  public isPermited(userRole: string): boolean {
    return (
      this.getPermission(this.currentRole) === this.getPermission(userRole)
    );
  }
}
----

We will use this service to fill it with information from the logged-in user once the user logs in. This will allow us to check the information of the logged-in user in any way necessary.

[NOTE]
====
You have already learned about Authentication in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#authentication[here]. +
You can go back and read that section again to refresh your memory.
====

Now we are going to use this class to fill the `auth-guard.service.ts`:

[source, typescript]
----
import { Injectable } from '@angular/core';
import {
  CanActivate,
  Router,
  ActivatedRouteSnapshot,
  RouterStateSnapshot,
} from '@angular/router';
import { AuthService } from './auth.service';

@Injectable({
  providedIn: 'root'
})
export class AuthGuardService implements CanActivate {
  constructor(
    private authService: AuthService,
    private router: Router,
  ) {}

  canActivate(
    route: ActivatedRouteSnapshot,
    state: RouterStateSnapshot,
  ): boolean {
    if (this.authService.isLogged() && this.authService.isPermited('VISITOR')) { // If its logged in and its role is visitor
      return true;
    }

    if (!this.authService.isLogged()) { // if its not logged in
      console.log('Error login');
    }

    if (this.router.url === '/') {  // if the router is the app route
      this.router.navigate(['/login']);
    }
    return false;
  }
}
----

This service will be slightly different because we have to implement an interface called `CanActivate`. It has a method called `canActivate()` returning a boolean. This method will be called when navigating to a specified route, and -- depending on the return value of this implemented method -- the navigation will proceed or be rejected.

[NOTE]
====
You have already learned about Guards in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#guards[here]. +
You can go back and read that section again to refresh your memory.
====

Once this is done, the last step is to fill the `login.service.ts`. In this case, there's going to be three methods:

. `getVisitorByUsername(username: string)`: +
A method that recovers a single user corresponding to the email.

. `login(username: string, password: string)`: +
A method, which is going to use the previous method, to check that the username and password match the form input and then fill the `AuthService`.

. `logout()`: +
This is going to be used to reset the `AuthService` and log out the user.

Also, we see the first use of `pipe` and `map`: +
`pipe` allows us to execute a chain of functions, then `map` allows us to return the single visitor instead of all the parameters that the server will send us.

[source, typescript]
----
import { map, tap } from 'rxjs/operators';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { Visitor, FilterVisitor, Pageable } from 'src/app/shared/backendModels/interfaces';
import { HttpClient } from '@angular/common/http';
import { environment } from 'src/environments/environment';
import { AuthService } from 'src/app/core/authentication/auth.service';
import { Router } from '@angular/router';
import { MatSnackBar } from '@angular/material/snack-bar';

@Injectable({
  providedIn: 'root'
})
export class LoginService {

    private baseUrl = environment.baseUrlRestServices;
    constructor(private router: Router, private http: HttpClient, private authService: AuthService, public snackBar: MatSnackBar) { }

    getVisitorByUsername(username: string): Observable<Visitor> {
        const filters: FilterVisitor = new FilterVisitor();
        const pageable: Pageable = new Pageable();

        pageable.pageNumber = 0;
        pageable.pageSize = 1;
        pageable.sort= [];
        filters.username = username;
        filters.pageable = pageable;
        return this.http.post<VisitorArray>(`${this.baseUrl}` + '/visitormanagement/v1/visitor/search', filters)
       .pipe(
            map(visitors => visitors.content[0]),
        );
    }

    login(username: string, password: string): void {
      // Checks if given username and password are the ones aved in the database
      this.getVisitorByUsername(username).subscribe(
          (visitorFound) => {
              if (visitorFound.username === username && visitorFound.password === password) {
                  this.authService.setUserId(visitorFound.id);
                  this.authService.setLogged(true);
                  this.authService.setUser(visitorFound.username);
                  if (visitorFound.userType === false) {
                      this.authService.setRole('VISITOR');
                      this.router.navigate(['ViewQueue']);
                  } else {
                      this.authService.setLogged(false);
                      this.snackBar.open('access error', 'OK', {
                          duration: 2000,
                        });
                  }
              } else {
                  this.snackBar.open('access error', 'OK', {
                      duration: 2000,
                    });
              }
          },
          (err: any) => {
            this.snackBar.open('access error', 'OK', {
              duration: 2000,
            });
          },
      );
    }

    logout(): void {
        this.authService.setLogged(false);
        this.authService.setUser('');
        this.authService.setUserId(0);
        this.router.navigate(['FormLogin']);
    }
}
----

If you remember the devon4j tutorial, we used `Criteria` in order to filter and to search the DB. The `Criteria` require a pageable and you can add extra parameters to get specific results. In `getVisitorByUsername()` you can see the creation of a `FilterVisitor` corresponding to the `Criteria` in the back-end. This `FilterVisitor` gets a `Pageable` and a `username` and will return a single result as soon as the POST call is performed. That's why we return the first page and only a single result.

[NOTE]
====
For the tutorial we are only considering the visitor side of the application. That's why we `setLogged(false)` if it's `userType === true` (BOSS side).
====

Then we add to the `login-module.ts` and `LoginService`:

[source, typescript]
----
...
import { LoginService } from './services/login.service';

@NgModule({
  ...
  providers: [LoginService],
  ...
})
...
----

After that, we are going to add the `AuthGuard` and the `Auth` into the `shared/core-module.ts`. This will allow us to employ these two services when importing the core module avoiding having to provide these services in every component:

[source, typescript]
----
...
  providers: [
    HttpClientModule,
    AuthService,
    AuthGuardService,
  ],
...
----

You need to import these modules as well, as shown earlier.

Finally, we modify the `login.component.html` to send the form values to the `login.component.ts` like we did with the register form. Afterwards, we are going to modify the `register.components.ts`: When the visitor registers, we can log him in automatically to avoid any nuisances. Let's start with the `login.component.html`:

[source, html]
----
...
<form (ngSubmit)=""submitLogin(loginForm.form.value)"" #loginForm=""ngForm"" layout-padding>
...
----

As you can see, in the form we just added, the values to the `ngSubmit` allow us to call the method `submitLogin()` within the logic, sending the `loginForm.form.values` which are the form's input values. In the next step we are going to modify the `login.components.ts`, adding the `submitLogin()` method. This method calls the `LoginService`, providing the service with the necessary values received from the form (i.e. the `loginFormValues`).

[source, typescript]
----
...
import { LoginService } from './services/login.service';
...
export class LoginComponent implements OnInit {
  ...
  constructor(private router: Router, private loginService: LoginService) {
  }
  ...
  submitLogin(loginFormValues): void {
    this.loginService.login(loginFormValues.username, loginFormValues.password);
  }
}
----

Finally, in the `register.components.ts` we are going to inject the `LoginService` and use it to login the visitor after registering him. This will also send the user to the `ViewQueue`, which we will create and secure later in the tutorial.

[source, typescript]
----
import { LoginService } from '../form-login/components/login/services/login.service';
...
constructor(private registerService: RegisterService, private router: Router, public snackBar: MatSnackBar,
    private loginService: LoginService) { } 
...
  submitRegister(formValue): void {
    ...
    this.registerService.registerVisitor(visitor).subscribe(
      (visitorResult: Visitor) => {
        this.loginService.login(visitorResult.username, visitorResult.password);
      },
      ...
    );
  }
...
----

== Finishing Touches

Now we only need to generate two more components (`header` and `view-queue`) and services (`AccessCodeService` and `QueueService`) in order to finish the implementation of our _JumpTheQueue_ app.

=== Separating Header from Layout

By separating the header on top of the page from the layout, we enable the reuse of this component and reach a better separation of concerns across our application. To do this, we are going to generate a new component inside `angular/src/app/layout/header` via:

```
ng generate component layout/header
```

Now we are going to add it to the main view `app.component.html`:

[source, html]
----
...
  <div td-toolbar-content flex>
    <app-header layout-align=""center center"" layout=""row"" flex></app-header>
  </div> <!-- Header container-->
...
----

After adding the component to the header view (`app-header`), we are going to modify the HTML of the component (`header.component.html`) and the logic of the component (`header.component.ts`). As a first step, we are going to modify the HTML, adding an icon as a button, which checks whether or not the user is logged in via `*ngIf` by calling the `auth` service's `isLogged()` method. This will make the icon appear only if the user is logged in:

[source, html]
----
Jump The Queue
<span flex></span> 
<button mat-icon-button mdTooltip=""Log out"" (click)=onClickLogout() *ngIf=""authService.isLogged()"">
  <mat-icon>exit_to_app</mat-icon>
</button>
----

In the header logic (`header.component.ts`) we are simply going to inject the `AuthService` and `LoginService`, then we are going call `logout()` from `LoginService` in the `OnClickLogout()`. Finally, the `AuthService` is needed because it's being used by the HTML template to control if the user is logged in with `isLogged()`:

[source, typescript]
----
...
  constructor(private authService: AuthService, private loginService: LoginService) { }
...
  onClickLogout(): void {
    this.loginService.logout();
  }
...
----

Separating components will allow us to keep the code clean and easy to work with.

=== `ViewQueue` Component

For the last view, we are going to learn how to use our Observables on the HTML template directly without having to `subscribe()` to them.

First, we are going to generate the component via:

```
ng generate component view-queue
```

After that, we are going to include the component in the `app-routing.module.ts`, also adding the guard, to only allow users that are `VISITOR` to see the component. It is important to insert the following code before `{ path: '**', redirectTo: '/FormLogin', pathMatch: 'full' }`:

[source, typescript]
----
...
const appRoutes: Routes = [
  ...
  { path: 'ViewQueue',
    component: ViewQueueComponent,
    canActivate: [AuthGuardService]}, // Redirect if url path is /ViewQueue, check if canActivate() with the AuthGuardService.
  ...
];
...
----

Now in order to make this view work, we are going to do these things:
  
. Add the `Queue` and `AccessCode` interface in our `angular/src/app/shared/backendModels/interfaces` and their corresponding filters.

. Generate the `QueueService` and `AccessCodeService` and add the necessary methods.

. Modify the `view-queue.component.html`.

. Modify the logic of the component `view-queue.component.ts`.

First, we are going to add the necessary interfaces. We modify `angular/src/app/shared/backendModels/interfaces.ts` and add the `FilterQueue`, `Queue`, `FilterAccessCode`, `AccessCode`, `QueueArray` and `AccessCodeArray`. These are going to be necessary in order to communicate with the back-end.

[source, typescript]
----
...
export class FilterAccessCode {
    pageable: Pageable;
    visitorId?: Number;
    endTime?: string;
}

export class FilterQueue {
    pageable: Pageable;
    active: boolean;
}

export class AccessCode {
    id?: number;
    ticketNumber: string;
    creationTime: string;
    startTime?: string;
    endTime?: string;
    visitorId: number;
    queueId: number;
    content: any;
}

export class Queue {
    id?: number;
    name: string;
    logo: string;
    currentNumber: string;
    attentionTime: string;
    minAttentionTime: string;
    active: boolean;
    customers: number;
    content: any;
}

export class QueueArray {
    content: Queue[];
}

export class AccessCodeArray {
    content: [{
        accessCode: AccessCode
    }];
}
...
----

=== AccessCode and Queue Services

After this is done, we are going to generate the `AccessCodeService` and the `QueueService`:

```
ng generate service view-queue/services/Queue

ng generate service view-queue/services/AccessCode
```

Once this is done, we are going to modify them and add the necessary methods: 

- For the `AccessCodeService` we are going to need a full CRUD:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { AuthService } from 'src/app/core/authentication/auth.service';
import { Router } from '@angular/router';
import { HttpClient } from '@angular/common/http';
import { AccessCode, Pageable, FilterAccessCode } from 'src/app/shared/backendModels/interfaces';
import { Observable } from 'rxjs';
import { environment } from 'src/environments/environment';
import { map } from 'rxjs/operators';

@Injectable({
  providedIn: 'root'
})
export class AccessCodeService {

  private baseUrl = environment.baseUrlRestServices;

  constructor(private router: Router, private http: HttpClient, private authService: AuthService) { }

  getCurrentlyAttendedAccessCode(): Observable<AccessCode> {
    const filters: FilterAccessCode = new FilterAccessCode();
    const pageable: Pageable = new Pageable();

    filters.endTime = null;
    pageable.pageNumber = 0;
    pageable.pageSize = 1;
    filters.pageable = pageable;
    return this.http.post<AccessCodeArray>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/cto/search', filters)
    .pipe(
        map(accesscodes => {
          if (!accesscodes.content[0]) {  // if theres no response it means theres noone in the queue
            return null;
          } else {
            if (accesscodes.content[0].accessCode.startTime != null) {
              // if start time is not null it means that hes being attended
              return accesscodes.content[0].accessCode;
            } else {
              // noone being attended
              return null;
            }
          }
        }),
     );
  }

  getVisitorAccessCode(visitorId: number): Observable<AccessCode> {
    const filters: FilterAccessCode = new FilterAccessCode();
    const pageable: Pageable = new Pageable();

    pageable.pageNumber = 0;
    pageable.pageSize = 1;
    filters.visitorId = visitorId;
    filters.pageable = pageable;
    return this.http.post<AccessCodeArray>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/cto/search', filters)
    .pipe(
      map(accesscodes => {
        if (accesscodes.content[0]) {
          return accesscodes.content[0].accessCode;
        } else {
          return null;
        }
      }),
    );
  }

  deleteAccessCode(codeAccessId: number) {
    this.http.delete<AccessCode>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/' + codeAccessId + '/').subscribe();
  }

  saveAccessCode(visitorId: number, queueId: number) {
    const accessCode: AccessCode = new AccessCode();
    accessCode.visitorId = visitorId;
    accessCode.queueId = queueId;
    return this.http.post<AccessCode>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/', accessCode);
  }
}
----

In the methods `getCurrentlyAttendedAccessCode` and `getVisitorAccessCode` we can see the use of `Pageable` and `FilterAccessCode` to match the `Criteria` in the back-end like we explained in previous steps. In this case, the `getVisitorAccessCode` method will be used to see if the visitor has an `AccessCode` and the `getCurrentlyAttendedAccessCode` is going to recover the first `AccessCode` of the queue.

- For the `QueueService` we are only going to need to find the active queue:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Router } from '@angular/router';
import { Observable } from 'rxjs';
import { Queue, FilterQueue, Pageable } from 'src/app/shared/backendModels/interfaces';
import { environment } from 'src/environments/environment';
import { map } from 'rxjs/operators';

@Injectable({
  providedIn: 'root'
})
export class QueueService {

  private baseUrl = environment.baseUrlRestServices;

  constructor(private router: Router, private http: HttpClient) { }

  getActiveQueue(): Observable<Queue> {
    const filters: FilterQueue = new FilterQueue();
    filters.active = true;
    const pageable: Pageable = new Pageable();
    pageable.pageNumber = 0;
    pageable.pageSize = 1;
    pageable.sort = [];
    filters.pageable = pageable;
    return this.http.post<QueueArray>(`${this.baseUrl}` + '/queuemanagement/v1/queue/search', filters)
    .pipe(
         map(queues => queues.content[0]),
     );
  }
}
----

Now we are going to create the template `view-queue.component.html` (which will use this data) and we will also introduce a new concept: `async` pipes in templates.

[source, html]
----
<td-layout *ngIf=""{
  accessCodeAttended: accessCodeAttended$ | async,
  accessCodeVisitor: accessCodeVisitor$  | async,
  queue: queue$ | async
} as data;"">
  <div *ngIf=""data.queue"">
    <mat-card>
    <img mat-card-image src=""assets/images/jumptheq.png"">
    
      <div *ngIf=""data.accessCodeVisitor"">
        <div class=""text-center row"">
          <h1 style=""margin-bottom:10px;"" class=""text-left text-xl push-md"">Your Number:</h1> 
        </div>
        <div class=""text-center row"">
          <h1 style=""font-size: 75px; margin:0px;"" class=""text-center text-xxl push-left-md"">{{data.accessCodeVisitor.ticketNumber}}</h1> 
        </div>
        <div style=""border-bottom: 2px solid black;"" class=""row"">
          <p class=""push-left-md"">Currently estimate time: 10:00:00</p>
        </div>
      </div>
      <div class=""text-center"">
        <div class=""text-center row"">
          <h1 style=""margin-bottom:10px;"" class=""text-left text-xl push-md"">Currently Being Attended:</h1> 
        </div>
        <div class=""row"">
          <h1 style=""font-size: 100px"" class=""text-center text-xxl push-lg"">{{data.accessCodeAttended?.ticketNumber}}</h1> 
        </div>
      </div>
      <div style=""border-top: 2px solid black;"" class=""pad-bottom-lg pad-top-lg text-center row"" *ngIf=""data.accessCodeVisitor === null"">
        <button mat-raised-button (click)=""onJoinQueue(data.queue.id)"" color=""primary"" class=""text-upper"">Join the queue</button> 
      </div>
    </mat-card>
    <div *ngIf=""data.accessCodeVisitor"" style=""margin: 8px;"" class=""row text-right"">
        <button mat-raised-button (click)=""onLeaveQueue(data.accessCodeVisitor.id)"" color=""primary"" class=""text-upper"">Leave the queue</button> 
    </div>
  </div>
  <div *ngIf=""data.queue === null || (data.queue !== null && data.queue.active === false)"" class=""row"">
    <h1 style=""font-size: 50px"" class=""text-center text-xxl push-lg"">The queue is not active try again later</h1> 
  </div>
</td-layout>
----

If you watch closely, the starting `td-layout` has an `*ngIf` inside it. This `*ngIf` allows us to asynchronously pipe the observables that we will assign in the next steps. This solution avoids having to use `subscribe()` (as it subscribes automatically) and -- as a result -- we don't have to worry about where to `unsubscribe()` from the observables.

In this HTML, we give `*ngif` another use: We use it to hide certain panels. Using `accessCodeVisitor`, we hide the ticket number panel and the ""leave the queue""-button and show the button to join the queue. On the contrary we can hide the ticket number and the ""leave the queue""-button and only show the ""join the queue""-button.

[NOTE]
====
In this case, since we are using HTTP and the calls are finite, there wouldn't be any problems if you don't `unsubscribe()` from their corresponding observables. However, if -- for example -- we use an observable to keep track of an input and `subscribe()` to it but not controlling the `unsubscribe()` method, the app could end up containing a memory leak. This is because -- every time we visit the component with the input -- it is going to create another subscription without unsubscribing from the last one.
====

Finally, to adapt the `async` pipe, the `ngOnInit()` method inside `view-queue.component.ts` now does not subscribe to the observable. In its place, we equal the queue variable directly to the observable, so we can load it using `*ngIf`.

[source, typescript]
----
import { Component, OnInit } from '@angular/core';
import { AccessCode, Queue } from '../shared/backendModels/interfaces';
import { Observable, timer } from 'rxjs';
import { AccessCodeService } from './services/access-code.service';
import { switchMap } from 'rxjs/operators';
import { AuthService } from '../core/authentication/auth.service';
import { QueueService } from './services/queue.service';

@Component({
  selector: 'app-view-queue',
  templateUrl: './view-queue.component.html',
  styleUrls: ['./view-queue.component.scss']
})
export class ViewQueueComponent implements OnInit {

  accessCodeAttended$: Observable<AccessCode>;
  accessCodeVisitor$: Observable<AccessCode>;
  queue$: Observable<Queue>;

  constructor(private accessCodeService: AccessCodeService, private queueService: QueueService, private authService: AuthService) { }

  ngOnInit() {
     // Every minute we are going to update accessCodeAttended$ starting instantly
    this.accessCodeAttended$ = timer(0, 60000).pipe(
      // we switchMap and give it the value necesary from the accessCodeService
      switchMap(() => {
        return this.accessCodeService.getCurrentlyAttendedAccessCode();
      })
    );
    this.accessCodeVisitor$ = this.accessCodeService.getVisitorAccessCode(this.authService.getUserId());
    this.queue$ = this.queueService.getActiveQueue();
  }

  onJoinQueue(queueId: number): void {
    this.accessCodeVisitor$ = this.accessCodeService.saveAccessCode(this.authService.getUserId(), queueId);
  }

  onLeaveQueue(accessCodeId: number): void {
    this.accessCodeService.deleteAccessCode(accessCodeId);
    this.accessCodeVisitor$ = null;
  }
}
----

In this last component we assign the `Observables` when the component is initiated. After that, when clicking the ""join the queue""-button, we assign a new `Observable` called `AccessCode` to the `accessCodeVisitor$`. Finally, when we leave the queue, we delete the `AccessCode` and set the `accessCodeVisitor` to null. Since we are using an `async` pipe, every time we modify the status of the `Observables`, they are going to update the template.

image::images/devon4ng/3.BuildYourOwn/withCodeAccess.png[Queue Page with Access Code, 250]

image::images/devon4ng/3.BuildYourOwn/withoutCodeAccess.png[Queue Page without Access Code, 250]

This is all on how to build your own devon4ng application. Now it's up to you to add features, change styles and do everything you can imagine doing with this app.

As a final step to complete the tutorial, however, we are going to run the app outside of our local machine by deploying it.

'''
*Next Chapter*: link:devon4ng-deployment.asciidoc[Deploy your devon4ng App]
",12344,False,2100.908344825376,median
"#ifndef WEBRTC_VAD_VAD_CORE_HPP
#define WEBRTC_VAD_VAD_CORE_HPP
#include ""webrtc/singal_processing/singal_processing_library.hpp""

namespace webrtc {
enum { kNumChannels = 6 };   // Number of frequency bands (named channels).
enum { kNumGaussians = 2 };  // Number of Gaussians per channel in the GMM.
enum { kTableSize = kNumChannels * kNumGaussians };
enum { kMinEnergy = 10 };  // Minimum energy required to trigger audio signal.

typedef struct VadInstT_ {
    int vad;
    int32_t downsampling_filter_states[4];
    WebRtcSpl_State48khzTo8khz state_48_to_8;
    int16_t noise_means[kTableSize];
    int16_t speech_means[kTableSize];
    int16_t noise_stds[kTableSize];
    int16_t speech_stds[kTableSize];
    // TODO(bjornv): Change to |frame_count|.
    int32_t frame_counter;
    int16_t over_hang;  // Over Hang
    int16_t num_of_speech;
    // TODO(bjornv): Change to |age_vector|.
    int16_t index_vector[16 * kNumChannels];
    int16_t low_value_vector[16 * kNumChannels];
    // TODO(bjornv): Change to |median|.
    int16_t mean_value[kNumChannels];
    int16_t upper_state[5];
    int16_t lower_state[5];
    int16_t hp_filter_state[4];
    int16_t over_hang_max_1[3];
    int16_t over_hang_max_2[3];
    int16_t individual[3];
    int16_t total[3];

    int init_flag;
} VadInstT;

// Initializes the core VAD component. The default aggressiveness mode is
// controlled by |kDefaultMode| in vad_core.c.
//
// - self [i/o] : Instance that should be initialized
//
// returns      : 0 (OK), -1 (null pointer in or if the default mode can't be
//                set)
int WebRtcVad_InitCore(VadInstT* self);

/****************************************************************************
 * WebRtcVad_set_mode_core(...)
 *
 * This function changes the VAD settings
 *
 * Input:
 *      - inst      : VAD instance
 *      - mode      : Aggressiveness degree
 *                    0 (High quality) - 3 (Highly aggressive)
 *
 * Output:
 *      - inst      : Changed  instance
 *
 * Return value     :  0 - Ok
 *                    -1 - Error
 */

int WebRtcVad_set_mode_core(VadInstT* self, int mode);

/****************************************************************************
 * WebRtcVad_CalcVad48khz(...)
 * WebRtcVad_CalcVad32khz(...)
 * WebRtcVad_CalcVad16khz(...)
 * WebRtcVad_CalcVad8khz(...)
 *
 * Calculate probability for active speech and make VAD decision.
 *
 * Input:
 *      - inst          : Instance that should be initialized
 *      - speech_frame  : Input speech frame
 *      - frame_length  : Number of input samples
 *
 * Output:
 *      - inst          : Updated filter states etc.
 *
 * Return value         : VAD decision
 *                        0 - No active speech
 *                        1-6 - Active speech
 */
int WebRtcVad_CalcVad48khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length);
int WebRtcVad_CalcVad32khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length);
int WebRtcVad_CalcVad16khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length);
int WebRtcVad_CalcVad8khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length);

// Downsamples the signal by a factor 2, eg. 32->16 or 16->8.
//
// Inputs:
//      - signal_in     : Input signal.
//      - in_length     : Length of input signal in samples.
//
// Input & Output:
//      - filter_state  : Current filter states of the two all-pass filters. The
//                        |filter_state| is updated after all samples have been
//                        processed.
//
// Output:
//      - signal_out    : Downsampled signal (of length |in_length| / 2).
void WebRtcVad_Downsampling(const int16_t* signal_in, int16_t* signal_out, int32_t* filter_state, size_t in_length);

// Updates and returns the smoothed feature minimum. As minimum we use the
// median of the five smallest feature values in a 100 frames long window.
// As long as |handle->frame_counter| is zero, that is, we haven't received any
// ""valid"" data, FindMinimum() outputs the default value of 1600.
//
// Inputs:
//      - feature_value : New feature value to update with.
//      - channel       : Channel number.
//
// Input & Output:
//      - handle        : State information of the VAD.
//
// Returns:
//                      : Smoothed minimum value for a moving window.
int16_t WebRtcVad_FindMinimum(VadInstT* handle, int16_t feature_value, int channel);

// Allpass filter coefficients, upper and lower, in Q13.
// Upper: 0.64, Lower: 0.17.
static const int16_t kAllPassCoefsQ13[2] = {5243, 1392};  // Q13.
static const int16_t kSmoothingDown = 6553;               // 0.2 in Q15.
static const int16_t kSmoothingUp = 32439;                // 0.99 in Q15.

// TODO(bjornv): Move this function to vad_filterbank.c.
// Downsampling filter based on splitting filter and allpass functions.
void WebRtcVad_Downsampling(const int16_t* signal_in, int16_t* signal_out, int32_t* filter_state, size_t in_length) {
    int16_t tmp16_1 = 0, tmp16_2 = 0;
    int32_t tmp32_1 = filter_state[0];
    int32_t tmp32_2 = filter_state[1];
    size_t n = 0;
    // Downsampling by 2 gives half length.
    size_t half_length = (in_length >> 1);

    // Filter coefficients in Q13, filter state in Q0.
    for (n = 0; n < half_length; n++) {
        // All-pass filtering upper branch.
        tmp16_1 = (int16_t)((tmp32_1 >> 1) + ((kAllPassCoefsQ13[0] * *signal_in) >> 14));
        *signal_out = tmp16_1;
        tmp32_1 = (int32_t)(*signal_in++) - ((kAllPassCoefsQ13[0] * tmp16_1) >> 12);

        // All-pass filtering lower branch.
        tmp16_2 = (int16_t)((tmp32_2 >> 1) + ((kAllPassCoefsQ13[1] * *signal_in) >> 14));
        *signal_out++ += tmp16_2;
        tmp32_2 = (int32_t)(*signal_in++) - ((kAllPassCoefsQ13[1] * tmp16_2) >> 12);
    }
    // Store the filter states.
    filter_state[0] = tmp32_1;
    filter_state[1] = tmp32_2;
}

// Inserts |feature_value| into |low_value_vector|, if it is one of the 16
// smallest values the last 100 frames. Then calculates and returns the median
// of the five smallest values.
int16_t WebRtcVad_FindMinimum(VadInstT* self, int16_t feature_value, int channel) {
    int i = 0, j = 0;
    int position = -1;
    // Offset to beginning of the 16 minimum values in memory.
    const int offset = (channel << 4);
    int16_t current_median = 1600;
    int16_t alpha = 0;
    int32_t tmp32 = 0;
    // Pointer to memory for the 16 minimum values and the age of each value of
    // the |channel|.
    int16_t* age = &self->index_vector[offset];
    int16_t* smallest_values = &self->low_value_vector[offset];

    RTC_DCHECK_LT(channel, kNumChannels);

    // Each value in |smallest_values| is getting 1 loop older. Update |age|, and
    // remove old values.
    for (i = 0; i < 16; i++) {
        if (age[i] != 100) {
            age[i]++;
        } else {
            // Too old value. Remove from memory and shift larger values downwards.
            for (j = i; j < 16; j++) {
                smallest_values[j] = smallest_values[j + 1];
                age[j] = age[j + 1];
            }
            age[15] = 101;
            smallest_values[15] = 10000;
        }
    }

    // Check if |feature_value| is smaller than any of the values in
    // |smallest_values|. If so, find the |position| where to insert the new value
    // (|feature_value|).
    if (feature_value < smallest_values[7]) {
        if (feature_value < smallest_values[3]) {
            if (feature_value < smallest_values[1]) {
                if (feature_value < smallest_values[0]) {
                    position = 0;
                } else {
                    position = 1;
                }
            } else if (feature_value < smallest_values[2]) {
                position = 2;
            } else {
                position = 3;
            }
        } else if (feature_value < smallest_values[5]) {
            if (feature_value < smallest_values[4]) {
                position = 4;
            } else {
                position = 5;
            }
        } else if (feature_value < smallest_values[6]) {
            position = 6;
        } else {
            position = 7;
        }
    } else if (feature_value < smallest_values[15]) {
        if (feature_value < smallest_values[11]) {
            if (feature_value < smallest_values[9]) {
                if (feature_value < smallest_values[8]) {
                    position = 8;
                } else {
                    position = 9;
                }
            } else if (feature_value < smallest_values[10]) {
                position = 10;
            } else {
                position = 11;
            }
        } else if (feature_value < smallest_values[13]) {
            if (feature_value < smallest_values[12]) {
                position = 12;
            } else {
                position = 13;
            }
        } else if (feature_value < smallest_values[14]) {
            position = 14;
        } else {
            position = 15;
        }
    }

    // If we have detected a new small value, insert it at the correct position
    // and shift larger values up.
    if (position > -1) {
        for (i = 15; i > position; i--) {
            smallest_values[i] = smallest_values[i - 1];
            age[i] = age[i - 1];
        }
        smallest_values[position] = feature_value;
        age[position] = 1;
    }

    // Get |current_median|.
    if (self->frame_counter > 2) {
        current_median = smallest_values[2];
    } else if (self->frame_counter > 0) {
        current_median = smallest_values[0];
    }

    // Smooth the median value.
    if (self->frame_counter > 0) {
        if (current_median < self->mean_value[channel]) {
            alpha = kSmoothingDown;  // 0.2 in Q15.
        } else {
            alpha = kSmoothingUp;  // 0.99 in Q15.
        }
    }
    tmp32 = (alpha + 1) * self->mean_value[channel];
    tmp32 += (WEBRTC_SPL_WORD16_MAX - alpha) * current_median;
    tmp32 += 16384;
    self->mean_value[channel] = (int16_t)(tmp32 >> 15);

    return self->mean_value[channel];
}

// Takes |data_length| samples of |data_in| and calculates the logarithm of the
// energy of each of the |kNumChannels| = 6 frequency bands used by the VAD:
//        80 Hz - 250 Hz
//        250 Hz - 500 Hz
//        500 Hz - 1000 Hz
//        1000 Hz - 2000 Hz
//        2000 Hz - 3000 Hz
//        3000 Hz - 4000 Hz
//
// The values are given in Q4 and written to |features|. Further, an approximate
// overall energy is returned. The return value is used in
// WebRtcVad_GmmProbability() as a signal indicator, hence it is arbitrary above
// the threshold |kMinEnergy|.
//
// - self         [i/o] : State information of the VAD.
// - data_in      [i]   : Input audio data, for feature extraction.
// - data_length  [i]   : Audio data size, in number of samples.
// - features     [o]   : 10 * log10(energy in each frequency band), Q4.
// - returns            : Total energy of the signal (NOTE! This value is not
//                        exact. It is only used in a comparison.)
int16_t WebRtcVad_CalculateFeatures(VadInstT* self, const int16_t* data_in, size_t data_length, int16_t* features);

// Constants used in LogOfEnergy().
static const int16_t kLogConst = 24660;          // 160*log10(2) in Q9.
static const int16_t kLogEnergyIntPart = 14336;  // 14 in Q10

// Coefficients used by HighPassFilter, Q14.
static const int16_t kHpZeroCoefs[3] = {6631, -13262, 6631};
static const int16_t kHpPoleCoefs[3] = {16384, -7756, 5620};

// Allpass filter coefficients, upper and lower, in Q15.
// Upper: 0.64, Lower: 0.17
static const int16_t kAllPassCoefsQ15[2] = {20972, 5571};

// Adjustment for division with two in SplitFilter.
static const int16_t kOffsetVector[6] = {368, 368, 272, 176, 176, 176};

// High pass filtering, with a cut-off frequency at 80 Hz, if the |data_in| is
// sampled at 500 Hz.
//
// - data_in      [i]   : Input audio data sampled at 500 Hz.
// - data_length  [i]   : Length of input and output data.
// - filter_state [i/o] : State of the filter.
// - data_out     [o]   : Output audio data in the frequency interval
//                        80 - 250 Hz.
static void HighPassFilter(const int16_t* data_in, size_t data_length, int16_t* filter_state, int16_t* data_out) {
    size_t i;
    const int16_t* in_ptr = data_in;
    int16_t* out_ptr = data_out;
    int32_t tmp32 = 0;


    // The sum of the absolute values of the impulse response:
    // The zero/pole-filter has a max amplification of a single sample of: 1.4546
    // Impulse response: 0.4047 -0.6179 -0.0266  0.1993  0.1035  -0.0194
    // The all-zero section has a max amplification of a single sample of: 1.6189
    // Impulse response: 0.4047 -0.8094  0.4047  0       0        0
    // The all-pole section has a max amplification of a single sample of: 1.9931
    // Impulse response: 1.0000  0.4734 -0.1189 -0.2187 -0.0627   0.04532

    for (i = 0; i < data_length; i++) {
        // All-zero section (filter coefficients in Q14).
        tmp32 = kHpZeroCoefs[0] * *in_ptr;
        tmp32 += kHpZeroCoefs[1] * filter_state[0];
        tmp32 += kHpZeroCoefs[2] * filter_state[1];
        filter_state[1] = filter_state[0];
        filter_state[0] = *in_ptr++;

        // All-pole section (filter coefficients in Q14).
        tmp32 -= kHpPoleCoefs[1] * filter_state[2];
        tmp32 -= kHpPoleCoefs[2] * filter_state[3];
        filter_state[3] = filter_state[2];
        filter_state[2] = (int16_t)(tmp32 >> 14);
        *out_ptr++ = filter_state[2];
    }
}

// All pass filtering of |data_in|, used before splitting the signal into two
// frequency bands (low pass vs high pass).
// Note that |data_in| and |data_out| can NOT correspond to the same address.
//
// - data_in            [i]   : Input audio signal given in Q0.
// - data_length        [i]   : Length of input and output data.
// - filter_coefficient [i]   : Given in Q15.
// - filter_state       [i/o] : State of the filter given in Q(-1).
// - data_out           [o]   : Output audio signal given in Q(-1).
static void AllPassFilter(const int16_t* data_in, size_t data_length, int16_t filter_coefficient, int16_t* filter_state,
                          int16_t* data_out) {
    // The filter can only cause overflow (in the w16 output variable)
    // if more than 4 consecutive input numbers are of maximum value and
    // has the the same sign as the impulse responses first taps.
    // First 6 taps of the impulse response:
    // 0.6399 0.5905 -0.3779 0.2418 -0.1547 0.0990

    size_t i;
    int16_t tmp16 = 0;
    int32_t tmp32 = 0;
    int32_t state32 = ((int32_t)(*filter_state) * (1 << 16));  // Q15

    for (i = 0; i < data_length; i++) {
        tmp32 = state32 + filter_coefficient * *data_in;
        tmp16 = (int16_t)(tmp32 >> 16);  // Q(-1)
        *data_out++ = tmp16;
        state32 = (*data_in * (1 << 14)) - filter_coefficient * tmp16;  // Q14
        state32 *= 2;                                                   // Q15.
        data_in += 2;
    }

    *filter_state = (int16_t)(state32 >> 16);  // Q(-1)
}

// Splits |data_in| into |hp_data_out| and |lp_data_out| corresponding to
// an upper (high pass) part and a lower (low pass) part respectively.
//
// - data_in      [i]   : Input audio data to be split into two frequency bands.
// - data_length  [i]   : Length of |data_in|.
// - upper_state  [i/o] : State of the upper filter, given in Q(-1).
// - lower_state  [i/o] : State of the lower filter, given in Q(-1).
// - hp_data_out  [o]   : Output audio data of the upper half of the spectrum.
//                        The length is |data_length| / 2.
// - lp_data_out  [o]   : Output audio data of the lower half of the spectrum.
//                        The length is |data_length| / 2.
static void SplitFilter(const int16_t* data_in, size_t data_length, int16_t* upper_state, int16_t* lower_state,
                        int16_t* hp_data_out, int16_t* lp_data_out) {
    size_t i;
    size_t half_length = data_length >> 1;  // Downsampling by 2.
    int16_t tmp_out;

    // All-pass filtering upper branch.
    AllPassFilter(&data_in[0], half_length, kAllPassCoefsQ15[0], upper_state, hp_data_out);

    // All-pass filtering lower branch.
    AllPassFilter(&data_in[1], half_length, kAllPassCoefsQ15[1], lower_state, lp_data_out);

    // Make LP and HP signals.
    for (i = 0; i < half_length; i++) {
        tmp_out = *hp_data_out;
        *hp_data_out++ -= *lp_data_out;
        *lp_data_out++ += tmp_out;
    }
}

// Calculates the energy of |data_in| in dB, and also updates an overall
// |total_energy| if necessary.
//
// - data_in      [i]   : Input audio data for energy calculation.
// - data_length  [i]   : Length of input data.
// - offset       [i]   : Offset value added to |log_energy|.
// - total_energy [i/o] : An external energy updated with the energy of
//                        |data_in|.
//                        NOTE: |total_energy| is only updated if
//                        |total_energy| <= |kMinEnergy|.
// - log_energy   [o]   : 10 * log10(""energy of |data_in|"") given in Q4.
static void LogOfEnergy(const int16_t* data_in, size_t data_length, int16_t offset, int16_t* total_energy,
                        int16_t* log_energy) {
    // |tot_rshifts| accumulates the number of right shifts performed on |energy|.
    int tot_rshifts = 0;
    // The |energy| will be normalized to 15 bits. We use unsigned integer because
    // we eventually will mask out the fractional part.
    uint32_t energy = 0;

    RTC_DCHECK(data_in);
    RTC_DCHECK_GT(data_length, 0);

    energy = (uint32_t)WebRtcSpl_Energy((int16_t*)data_in, data_length, &tot_rshifts);

    if (energy != 0) {
        // By construction, normalizing to 15 bits is equivalent with 17 leading
        // zeros of an unsigned 32 bit value.
        int normalizing_rshifts = 17 - WebRtcSpl_NormU32(energy);
        // In a 15 bit representation the leading bit is 2^14. log2(2^14) in Q10 is
        // (14 << 10), which is what we initialize |log2_energy| with. For a more
        // detailed derivations, see below.
        int16_t log2_energy = kLogEnergyIntPart;

        tot_rshifts += normalizing_rshifts;
        // Normalize |energy| to 15 bits.
        // |tot_rshifts| is now the total number of right shifts performed on
        // |energy| after normalization. This means that |energy| is in
        // Q(-tot_rshifts).
        if (normalizing_rshifts < 0) {
            energy <<= -normalizing_rshifts;
        } else {
            energy >>= normalizing_rshifts;
        }

        // Calculate the energy of |data_in| in dB, in Q4.
        //
        // 10 * log10(""true energy"") in Q4 = 2^4 * 10 * log10(""true energy"") =
        // 160 * log10(|energy| * 2^|tot_rshifts|) =
        // 160 * log10(2) * log2(|energy| * 2^|tot_rshifts|) =
        // 160 * log10(2) * (log2(|energy|) + log2(2^|tot_rshifts|)) =
        // (160 * log10(2)) * (log2(|energy|) + |tot_rshifts|) =
        // |kLogConst| * (|log2_energy| + |tot_rshifts|)
        //
        // We know by construction that |energy| is normalized to 15 bits. Hence,
        // |energy| = 2^14 + frac_Q15, where frac_Q15 is a fractional part in Q15.
        // Further, we'd like |log2_energy| in Q10
        // log2(|energy|) in Q10 = 2^10 * log2(2^14 + frac_Q15) =
        // 2^10 * log2(2^14 * (1 + frac_Q15 * 2^-14)) =
        // 2^10 * (14 + log2(1 + frac_Q15 * 2^-14)) ~=
        // (14 << 10) + 2^10 * (frac_Q15 * 2^-14) =
        // (14 << 10) + (frac_Q15 * 2^-4) = (14 << 10) + (frac_Q15 >> 4)
        //
        // Note that frac_Q15 = (|energy| & 0x00003FFF)

        // Calculate and add the fractional part to |log2_energy|.
        log2_energy += (int16_t)((energy & 0x00003FFF) >> 4);

        // |kLogConst| is in Q9, |log2_energy| in Q10 and |tot_rshifts| in Q0.
        // Note that we in our derivation above have accounted for an output in Q4.
        *log_energy = (int16_t)(((kLogConst * log2_energy) >> 19) + ((tot_rshifts * kLogConst) >> 9));

        if (*log_energy < 0) {
            *log_energy = 0;
        }
    } else {
        *log_energy = offset;
        return;
    }

    *log_energy += offset;

    // Update the approximate |total_energy| with the energy of |data_in|, if
    // |total_energy| has not exceeded |kMinEnergy|. |total_energy| is used as an
    // energy indicator in WebRtcVad_GmmProbability() in vad_core.c.
    if (*total_energy <= kMinEnergy) {
        if (tot_rshifts >= 0) {
            // We know by construction that the |energy| > |kMinEnergy| in Q0, so add
            // an arbitrary value such that |total_energy| exceeds |kMinEnergy|.
            *total_energy += kMinEnergy + 1;
        } else {
            // By construction |energy| is represented by 15 bits, hence any number of
            // right shifted |energy| will fit in an int16_t. In addition, adding the
            // value to |total_energy| is wrap around safe as long as
            // |kMinEnergy| < 8192.
            *total_energy += (int16_t)(energy >> -tot_rshifts);  // Q0.
        }
    }
}

int16_t WebRtcVad_CalculateFeatures(VadInstT* self, const int16_t* data_in, size_t data_length, int16_t* features) {
    int16_t total_energy = 0;
    // We expect |data_length| to be 80, 160 or 240 samples, which corresponds to
    // 10, 20 or 30 ms in 8 kHz. Therefore, the intermediate downsampled data will
    // have at most 120 samples after the first split and at most 60 samples after
    // the second split.
    int16_t hp_120[120], lp_120[120];
    int16_t hp_60[60], lp_60[60];
    const size_t half_data_length = data_length >> 1;
    size_t length = half_data_length;  // |data_length| / 2, corresponds to
                                       // bandwidth = 2000 Hz after downsampling.

    // Initialize variables for the first SplitFilter().
    int frequency_band = 0;
    const int16_t* in_ptr = data_in;  // [0 - 4000] Hz.
    int16_t* hp_out_ptr = hp_120;     // [2000 - 4000] Hz.
    int16_t* lp_out_ptr = lp_120;     // [0 - 2000] Hz.

    RTC_DCHECK_LE(data_length, 240);
    RTC_DCHECK_LT(4, kNumChannels - 1);  // Checking maximum |frequency_band|.

    // Split at 2000 Hz and downsample.
    SplitFilter(in_ptr, data_length, &self->upper_state[frequency_band], &self->lower_state[frequency_band], hp_out_ptr,
                lp_out_ptr);

    // For the upper band (2000 Hz - 4000 Hz) split at 3000 Hz and downsample.
    frequency_band = 1;
    in_ptr = hp_120;     // [2000 - 4000] Hz.
    hp_out_ptr = hp_60;  // [3000 - 4000] Hz.
    lp_out_ptr = lp_60;  // [2000 - 3000] Hz.
    SplitFilter(in_ptr, length, &self->upper_state[frequency_band], &self->lower_state[frequency_band], hp_out_ptr,
                lp_out_ptr);

    // Energy in 3000 Hz - 4000 Hz.
    length >>= 1;  // |data_length| / 4 <=> bandwidth = 1000 Hz.

    LogOfEnergy(hp_60, length, kOffsetVector[5], &total_energy, &features[5]);

    // Energy in 2000 Hz - 3000 Hz.
    LogOfEnergy(lp_60, length, kOffsetVector[4], &total_energy, &features[4]);

    // For the lower band (0 Hz - 2000 Hz) split at 1000 Hz and downsample.
    frequency_band = 2;
    in_ptr = lp_120;            // [0 - 2000] Hz.
    hp_out_ptr = hp_60;         // [1000 - 2000] Hz.
    lp_out_ptr = lp_60;         // [0 - 1000] Hz.
    length = half_data_length;  // |data_length| / 2 <=> bandwidth = 2000 Hz.
    SplitFilter(in_ptr, length, &self->upper_state[frequency_band], &self->lower_state[frequency_band], hp_out_ptr,
                lp_out_ptr);

    // Energy in 1000 Hz - 2000 Hz.
    length >>= 1;  // |data_length| / 4 <=> bandwidth = 1000 Hz.
    LogOfEnergy(hp_60, length, kOffsetVector[3], &total_energy, &features[3]);

    // For the lower band (0 Hz - 1000 Hz) split at 500 Hz and downsample.
    frequency_band = 3;
    in_ptr = lp_60;       // [0 - 1000] Hz.
    hp_out_ptr = hp_120;  // [500 - 1000] Hz.
    lp_out_ptr = lp_120;  // [0 - 500] Hz.
    SplitFilter(in_ptr, length, &self->upper_state[frequency_band], &self->lower_state[frequency_band], hp_out_ptr,
                lp_out_ptr);

    // Energy in 500 Hz - 1000 Hz.
    length >>= 1;  // |data_length| / 8 <=> bandwidth = 500 Hz.
    LogOfEnergy(hp_120, length, kOffsetVector[2], &total_energy, &features[2]);

    // For the lower band (0 Hz - 500 Hz) split at 250 Hz and downsample.
    frequency_band = 4;
    in_ptr = lp_120;     // [0 - 500] Hz.
    hp_out_ptr = hp_60;  // [250 - 500] Hz.
    lp_out_ptr = lp_60;  // [0 - 250] Hz.
    SplitFilter(in_ptr, length, &self->upper_state[frequency_band], &self->lower_state[frequency_band], hp_out_ptr,
                lp_out_ptr);

    // Energy in 250 Hz - 500 Hz.
    length >>= 1;  // |data_length| / 16 <=> bandwidth = 250 Hz.
    LogOfEnergy(hp_60, length, kOffsetVector[1], &total_energy, &features[1]);

    // Remove 0 Hz - 80 Hz, by high pass filtering the lower band.
    HighPassFilter(lp_60, length, self->hp_filter_state, hp_120);

    // Energy in 80 Hz - 250 Hz.
    LogOfEnergy(hp_120, length, kOffsetVector[0], &total_energy, &features[0]);

    return total_energy;
}
}  // namespace webrtc

#include <string.h>

#include ""webrtc/vad/vad_gmm.hpp""

namespace webrtc {
// Spectrum Weighting
static const int16_t kSpectrumWeight[kNumChannels] = {6, 8, 10, 12, 14, 16};
static const int16_t kNoiseUpdateConst = 655;    // Q15
static const int16_t kSpeechUpdateConst = 6554;  // Q15
static const int16_t kBackEta = 154;             // Q8
// Minimum difference between the two models, Q5
static const int16_t kMinimumDifference[kNumChannels] = {544, 544, 576, 576, 576, 576};
// Upper limit of mean value for speech model, Q7
static const int16_t kMaximumSpeech[kNumChannels] = {11392, 11392, 11520, 11520, 11520, 11520};
// Minimum value for mean value
static const int16_t kMinimumMean[kNumGaussians] = {640, 768};
// Upper limit of mean value for noise model, Q7
static const int16_t kMaximumNoise[kNumChannels] = {9216, 9088, 8960, 8832, 8704, 8576};
// Start values for the Gaussian models, Q7
// Weights for the two Gaussians for the six channels (noise)
static const int16_t kNoiseDataWeights[kTableSize] = {34, 62, 72, 66, 53, 25, 94, 66, 56, 62, 75, 103};
// Weights for the two Gaussians for the six channels (speech)
static const int16_t kSpeechDataWeights[kTableSize] = {48, 82, 45, 87, 50, 47, 80, 46, 83, 41, 78, 81};
// Means for the two Gaussians for the six channels (noise)
static const int16_t kNoiseDataMeans[kTableSize] = {6738, 4892, 7065, 6715, 6771, 3369,
                                                    7646, 3863, 7820, 7266, 5020, 4362};
// Means for the two Gaussians for the six channels (speech)
static const int16_t kSpeechDataMeans[kTableSize] = {8306, 10085, 10078, 11823, 11843, 6309,
                                                     9473, 9571,  10879, 7581,  8180,  7483};
// Stds for the two Gaussians for the six channels (noise)
static const int16_t kNoiseDataStds[kTableSize] = {378, 1064, 493, 582, 688, 593, 474, 697, 475, 688, 421, 455};
// Stds for the two Gaussians for the six channels (speech)
static const int16_t kSpeechDataStds[kTableSize] = {555, 505, 567, 524, 585, 1231, 509, 828, 492, 1540, 1079, 850};

// Constants used in GmmProbability().
//
// Maximum number of counted speech (VAD = 1) frames in a row.
static const int16_t kMaxSpeechFrames = 6;
// Minimum standard deviation for both speech and noise.
static const int16_t kMinStd = 384;

// Constants in WebRtcVad_InitCore().
// Default aggressiveness mode.
static const short kDefaultMode = 0;
static const int kInitCheck = 42;

// Constants used in WebRtcVad_set_mode_core().
//
// Thresholds for different frame lengths (10 ms, 20 ms and 30 ms).
//
// Mode 0, Quality.
static const int16_t kOverHangMax1Q[3] = {8, 4, 3};
static const int16_t kOverHangMax2Q[3] = {14, 7, 5};
static const int16_t kLocalThresholdQ[3] = {24, 21, 24};
static const int16_t kGlobalThresholdQ[3] = {57, 48, 57};
// Mode 1, Low bitrate.
static const int16_t kOverHangMax1LBR[3] = {8, 4, 3};
static const int16_t kOverHangMax2LBR[3] = {14, 7, 5};
static const int16_t kLocalThresholdLBR[3] = {37, 32, 37};
static const int16_t kGlobalThresholdLBR[3] = {100, 80, 100};
// Mode 2, Aggressive.
static const int16_t kOverHangMax1AGG[3] = {6, 3, 2};
static const int16_t kOverHangMax2AGG[3] = {9, 5, 3};
static const int16_t kLocalThresholdAGG[3] = {82, 78, 82};
static const int16_t kGlobalThresholdAGG[3] = {285, 260, 285};
// Mode 3, Very aggressive.
static const int16_t kOverHangMax1VAG[3] = {6, 3, 2};
static const int16_t kOverHangMax2VAG[3] = {9, 5, 3};
static const int16_t kLocalThresholdVAG[3] = {94, 94, 94};
static const int16_t kGlobalThresholdVAG[3] = {1100, 1050, 1100};

// Calculates the weighted average w.r.t. number of Gaussians. The |data| are
// updated with an |offset| before averaging.
//
// - data     [i/o] : Data to average.
// - offset   [i]   : An offset added to |data|.
// - weights  [i]   : Weights used for averaging.
//
// returns          : The weighted average.
static int32_t WeightedAverage(int16_t* data, int16_t offset, const int16_t* weights) {
    int k;
    int32_t weighted_average = 0;

    for (k = 0; k < kNumGaussians; k++) {
        data[k * kNumChannels] += offset;
        weighted_average += data[k * kNumChannels] * weights[k * kNumChannels];
    }
    return weighted_average;
}

// An s16 x s32 -> s32 multiplication that's allowed to overflow. (It's still
// undefined behavior, so not a good idea; this just makes UBSan ignore the
// violation, so that our old code can continue to do what it's always been
// doing.)
static inline int32_t RTC_NO_SANITIZE(""signed-integer-overflow"") OverflowingMulS16ByS32ToS32(int16_t a, int32_t b) {
    return a * b;
}

// Calculates the probabilities for both speech and background noise using
// Gaussian Mixture Models (GMM). A hypothesis-test is performed to decide which
// type of signal is most probable.
//
// - self           [i/o] : Pointer to VAD instance
// - features       [i]   : Feature vector of length |kNumChannels|
//                          = log10(energy in frequency band)
// - total_power    [i]   : Total power in audio frame.
// - frame_length   [i]   : Number of input samples
//
// - returns              : the VAD decision (0 - noise, 1 - speech).
static int16_t GmmProbability(VadInstT* self, int16_t* features, int16_t total_power, size_t frame_length) {
    int channel, k;
    int16_t feature_minimum;
    int16_t h0, h1;
    int16_t log_likelihood_ratio;
    int16_t vadflag = 0;
    int16_t shifts_h0, shifts_h1;
    int16_t tmp_s16, tmp1_s16, tmp2_s16;
    int16_t diff;
    int gaussian;
    int16_t nmk, nmk2, nmk3, smk, smk2, nsk, ssk;
    int16_t delt, ndelt;
    int16_t maxspe, maxmu;
    int16_t deltaN[kTableSize], deltaS[kTableSize];
    int16_t ngprvec[kTableSize] = {0};  // Conditional probability = 0.
    int16_t sgprvec[kTableSize] = {0};  // Conditional probability = 0.
    int32_t h0_test, h1_test;
    int32_t tmp1_s32, tmp2_s32;
    int32_t sum_log_likelihood_ratios = 0;
    int32_t noise_global_mean, speech_global_mean;
    int32_t noise_probability[kNumGaussians], speech_probability[kNumGaussians];
    int16_t overhead1, overhead2, individualTest, totalTest;

    // Set various thresholds based on frame lengths (80, 160 or 240 samples).
    if (frame_length == 80) {
        overhead1 = self->over_hang_max_1[0];
        overhead2 = self->over_hang_max_2[0];
        individualTest = self->individual[0];
        totalTest = self->total[0];
    } else if (frame_length == 160) {
        overhead1 = self->over_hang_max_1[1];
        overhead2 = self->over_hang_max_2[1];
        individualTest = self->individual[1];
        totalTest = self->total[1];
    } else {
        overhead1 = self->over_hang_max_1[2];
        overhead2 = self->over_hang_max_2[2];
        individualTest = self->individual[2];
        totalTest = self->total[2];
    }

    if (total_power > kMinEnergy) {
        // The signal power of current frame is large enough for processing. The
        // processing consists of two parts:
        // 1) Calculating the likelihood of speech and thereby a VAD decision.
        // 2) Updating the underlying model, w.r.t., the decision made.

        // The detection scheme is an LRT with hypothesis
        // H0: Noise
        // H1: Speech
        //
        // We combine a global LRT with local tests, for each frequency sub-band,
        // here defined as |channel|.
        for (channel = 0; channel < kNumChannels; channel++) {
            // For each channel we model the probability with a GMM consisting of
            // |kNumGaussians|, with different means and standard deviations depending
            // on H0 or H1.
            h0_test = 0;
            h1_test = 0;
            for (k = 0; k < kNumGaussians; k++) {
                gaussian = channel + k * kNumChannels;
                // Probability under H0, that is, probability of frame being noise.
                // Value given in Q27 = Q7 * Q20.
                tmp1_s32 = WebRtcVad_GaussianProbability(features[channel], self->noise_means[gaussian],
                                                         self->noise_stds[gaussian], &deltaN[gaussian]);
                noise_probability[k] = kNoiseDataWeights[gaussian] * tmp1_s32;
                h0_test += noise_probability[k];  // Q27

                // Probability under H1, that is, probability of frame being speech.
                // Value given in Q27 = Q7 * Q20.
                tmp1_s32 = WebRtcVad_GaussianProbability(features[channel], self->speech_means[gaussian],
                                                         self->speech_stds[gaussian], &deltaS[gaussian]);
                speech_probability[k] = kSpeechDataWeights[gaussian] * tmp1_s32;
                h1_test += speech_probability[k];  // Q27
            }

            // Calculate the log likelihood ratio: log2(Pr{X|H1} / Pr{X|H1}).
            // Approximation:
            // log2(Pr{X|H1} / Pr{X|H1}) = log2(Pr{X|H1}*2^Q) - log2(Pr{X|H1}*2^Q)
            //                           = log2(h1_test) - log2(h0_test)
            //                           = log2(2^(31-shifts_h1)*(1+b1))
            //                             - log2(2^(31-shifts_h0)*(1+b0))
            //                           = shifts_h0 - shifts_h1
            //                             + log2(1+b1) - log2(1+b0)
            //                          ~= shifts_h0 - shifts_h1
            //
            // Note that b0 and b1 are values less than 1, hence, 0 <= log2(1+b0) < 1.
            // Further, b0 and b1 are independent and on the average the two terms
            // cancel.
            shifts_h0 = WebRtcSpl_NormW32(h0_test);
            shifts_h1 = WebRtcSpl_NormW32(h1_test);
            if (h0_test == 0) {
                shifts_h0 = 31;
            }
            if (h1_test == 0) {
                shifts_h1 = 31;
            }
            log_likelihood_ratio = shifts_h0 - shifts_h1;

            // Update |sum_log_likelihood_ratios| with spectrum weighting. This is
            // used for the global VAD decision.
            sum_log_likelihood_ratios += (int32_t)(log_likelihood_ratio * kSpectrumWeight[channel]);

            // Local VAD decision.
            if ((log_likelihood_ratio * 4) > individualTest) {
                vadflag = 1;
            }

            // TODO(bjornv): The conditional probabilities below are applied on the
            // hard coded number of Gaussians set to two. Find a way to generalize.
            // Calculate local noise probabilities used later when updating the GMM.
            h0 = (int16_t)(h0_test >> 12);  // Q15
            if (h0 > 0) {
                // High probability of noise. Assign conditional probabilities for each
                // Gaussian in the GMM.
                tmp1_s32 = (noise_probability[0] & 0xFFFFF000) << 2;            // Q29
                ngprvec[channel] = (int16_t)WebRtcSpl_DivW32W16(tmp1_s32, h0);  // Q14
                ngprvec[channel + kNumChannels] = 16384 - ngprvec[channel];
            } else {
                // Low noise probability. Assign conditional probability 1 to the first
                // Gaussian and 0 to the rest (which is already set at initialization).
                ngprvec[channel] = 16384;
            }

            // Calculate local speech probabilities used later when updating the GMM.
            h1 = (int16_t)(h1_test >> 12);  // Q15
            if (h1 > 0) {
                // High probability of speech. Assign conditional probabilities for each
                // Gaussian in the GMM. Otherwise use the initialized values, i.e., 0.
                tmp1_s32 = (speech_probability[0] & 0xFFFFF000) << 2;           // Q29
                sgprvec[channel] = (int16_t)WebRtcSpl_DivW32W16(tmp1_s32, h1);  // Q14
                sgprvec[channel + kNumChannels] = 16384 - sgprvec[channel];
            }
        }

        // Make a global VAD decision.
        vadflag |= (sum_log_likelihood_ratios >= totalTest);

        // Update the model parameters.
        maxspe = 12800;
        for (channel = 0; channel < kNumChannels; channel++) {
            // Get minimum value in past which is used for long term correction in Q4.
            feature_minimum = WebRtcVad_FindMinimum(self, features[channel], channel);

            // Compute the ""global"" mean, that is the sum of the two means weighted.
            noise_global_mean = WeightedAverage(&self->noise_means[channel], 0, &kNoiseDataWeights[channel]);
            tmp1_s16 = (int16_t)(noise_global_mean >> 6);  // Q8

            for (k = 0; k < kNumGaussians; k++) {
                gaussian = channel + k * kNumChannels;

                nmk = self->noise_means[gaussian];
                smk = self->speech_means[gaussian];
                nsk = self->noise_stds[gaussian];
                ssk = self->speech_stds[gaussian];

                // Update noise mean vector if the frame consists of noise only.
                nmk2 = nmk;
                if (!vadflag) {
                    // deltaN = (x-mu)/sigma^2
                    // ngprvec[k] = |noise_probability[k]| /
                    //   (|noise_probability[0]| + |noise_probability[1]|)

                    // (Q14 * Q11 >> 11) = Q14.
                    delt = (int16_t)((ngprvec[gaussian] * deltaN[gaussian]) >> 11);
                    // Q7 + (Q14 * Q15 >> 22) = Q7.
                    nmk2 = nmk + (int16_t)((delt * kNoiseUpdateConst) >> 22);
                }

                // Long term correction of the noise mean.
                // Q8 - Q8 = Q8.
                ndelt = (feature_minimum << 4) - tmp1_s16;
                // Q7 + (Q8 * Q8) >> 9 = Q7.
                nmk3 = nmk2 + (int16_t)((ndelt * kBackEta) >> 9);

                // Control that the noise mean does not drift to much.
                tmp_s16 = (int16_t)((k + 5) << 7);
                if (nmk3 < tmp_s16) {
                    nmk3 = tmp_s16;
                }
                tmp_s16 = (int16_t)((72 + k - channel) << 7);
                if (nmk3 > tmp_s16) {
                    nmk3 = tmp_s16;
                }
                self->noise_means[gaussian] = nmk3;

                if (vadflag) {
                    // Update speech mean vector:
                    // |deltaS| = (x-mu)/sigma^2
                    // sgprvec[k] = |speech_probability[k]| /
                    //   (|speech_probability[0]| + |speech_probability[1]|)

                    // (Q14 * Q11) >> 11 = Q14.
                    delt = (int16_t)((sgprvec[gaussian] * deltaS[gaussian]) >> 11);
                    // Q14 * Q15 >> 21 = Q8.
                    tmp_s16 = (int16_t)((delt * kSpeechUpdateConst) >> 21);
                    // Q7 + (Q8 >> 1) = Q7. With rounding.
                    smk2 = smk + ((tmp_s16 + 1) >> 1);

                    // Control that the speech mean does not drift to much.
                    maxmu = maxspe + 640;
                    if (smk2 < kMinimumMean[k]) {
                        smk2 = kMinimumMean[k];
                    }
                    if (smk2 > maxmu) {
                        smk2 = maxmu;
                    }
                    self->speech_means[gaussian] = smk2;  // Q7.

                    // (Q7 >> 3) = Q4. With rounding.
                    tmp_s16 = ((smk + 4) >> 3);

                    tmp_s16 = features[channel] - tmp_s16;  // Q4
                    // (Q11 * Q4 >> 3) = Q12.
                    tmp1_s32 = (deltaS[gaussian] * tmp_s16) >> 3;
                    tmp2_s32 = tmp1_s32 - 4096;
                    tmp_s16 = sgprvec[gaussian] >> 2;
                    // (Q14 >> 2) * Q12 = Q24.
                    tmp1_s32 = tmp_s16 * tmp2_s32;

                    tmp2_s32 = tmp1_s32 >> 4;  // Q20

                    // 0.1 * Q20 / Q7 = Q13.
                    if (tmp2_s32 > 0) {
                        tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(tmp2_s32, ssk * 10);
                    } else {
                        tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(-tmp2_s32, ssk * 10);
                        tmp_s16 = -tmp_s16;
                    }
                    // Divide by 4 giving an update factor of 0.025 (= 0.1 / 4).
                    // Note that division by 4 equals shift by 2, hence,
                    // (Q13 >> 8) = (Q13 >> 6) / 4 = Q7.
                    tmp_s16 += 128;  // Rounding.
                    ssk += (tmp_s16 >> 8);
                    if (ssk < kMinStd) {
                        ssk = kMinStd;
                    }
                    self->speech_stds[gaussian] = ssk;
                } else {
                    // Update GMM variance vectors.
                    // deltaN * (features[channel] - nmk) - 1
                    // Q4 - (Q7 >> 3) = Q4.
                    tmp_s16 = features[channel] - (nmk >> 3);
                    // (Q11 * Q4 >> 3) = Q12.
                    tmp1_s32 = (deltaN[gaussian] * tmp_s16) >> 3;
                    tmp1_s32 -= 4096;

                    // (Q14 >> 2) * Q12 = Q24.
                    tmp_s16 = (ngprvec[gaussian] + 2) >> 2;
                    tmp2_s32 = OverflowingMulS16ByS32ToS32(tmp_s16, tmp1_s32);
                    // Q20  * approx 0.001 (2^-10=0.0009766), hence,
                    // (Q24 >> 14) = (Q24 >> 4) / 2^10 = Q20.
                    tmp1_s32 = tmp2_s32 >> 14;

                    // Q20 / Q7 = Q13.
                    if (tmp1_s32 > 0) {
                        tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(tmp1_s32, nsk);
                    } else {
                        tmp_s16 = (int16_t)WebRtcSpl_DivW32W16(-tmp1_s32, nsk);
                        tmp_s16 = -tmp_s16;
                    }
                    tmp_s16 += 32;        // Rounding
                    nsk += tmp_s16 >> 6;  // Q13 >> 6 = Q7.
                    if (nsk < kMinStd) {
                        nsk = kMinStd;
                    }
                    self->noise_stds[gaussian] = nsk;
                }
            }

            // Separate models if they are too close.
            // |noise_global_mean| in Q14 (= Q7 * Q7).
            noise_global_mean = WeightedAverage(&self->noise_means[channel], 0, &kNoiseDataWeights[channel]);

            // |speech_global_mean| in Q14 (= Q7 * Q7).
            speech_global_mean = WeightedAverage(&self->speech_means[channel], 0, &kSpeechDataWeights[channel]);

            // |diff| = ""global"" speech mean - ""global"" noise mean.
            // (Q14 >> 9) - (Q14 >> 9) = Q5.
            diff = (int16_t)(speech_global_mean >> 9) - (int16_t)(noise_global_mean >> 9);
            if (diff < kMinimumDifference[channel]) {
                tmp_s16 = kMinimumDifference[channel] - diff;

                // |tmp1_s16| = ~0.8 * (kMinimumDifference - diff) in Q7.
                // |tmp2_s16| = ~0.2 * (kMinimumDifference - diff) in Q7.
                tmp1_s16 = (int16_t)((13 * tmp_s16) >> 2);
                tmp2_s16 = (int16_t)((3 * tmp_s16) >> 2);

                // Move Gaussian means for speech model by |tmp1_s16| and update
                // |speech_global_mean|. Note that |self->speech_means[channel]| is
                // changed after the call.
                speech_global_mean =
                    WeightedAverage(&self->speech_means[channel], tmp1_s16, &kSpeechDataWeights[channel]);

                // Move Gaussian means for noise model by -|tmp2_s16| and update
                // |noise_global_mean|. Note that |self->noise_means[channel]| is
                // changed after the call.
                noise_global_mean =
                    WeightedAverage(&self->noise_means[channel], -tmp2_s16, &kNoiseDataWeights[channel]);
            }

            // Control that the speech & noise means do not drift to much.
            maxspe = kMaximumSpeech[channel];
            tmp2_s16 = (int16_t)(speech_global_mean >> 7);
            if (tmp2_s16 > maxspe) {
                // Upper limit of speech model.
                tmp2_s16 -= maxspe;

                for (k = 0; k < kNumGaussians; k++) {
                    self->speech_means[channel + k * kNumChannels] -= tmp2_s16;
                }
            }

            tmp2_s16 = (int16_t)(noise_global_mean >> 7);
            if (tmp2_s16 > kMaximumNoise[channel]) {
                tmp2_s16 -= kMaximumNoise[channel];

                for (k = 0; k < kNumGaussians; k++) {
                    self->noise_means[channel + k * kNumChannels] -= tmp2_s16;
                }
            }
        }
        self->frame_counter++;
    }

    // Smooth with respect to transition hysteresis.
    if (!vadflag) {
        if (self->over_hang > 0) {
            vadflag = 2 + self->over_hang;
            self->over_hang--;
        }
        self->num_of_speech = 0;
    } else {
        self->num_of_speech++;
        if (self->num_of_speech > kMaxSpeechFrames) {
            self->num_of_speech = kMaxSpeechFrames;
            self->over_hang = overhead2;
        } else {
            self->over_hang = overhead1;
        }
    }
    return vadflag;
}

// Initialize the VAD. Set aggressiveness mode to default value.
int WebRtcVad_InitCore(VadInstT* self) {
    int i;

    if (self == NULL) {
        return -1;
    }

    // Initialization of general struct variables.
    self->vad = 1;  // Speech active (=1).
    self->frame_counter = 0;
    self->over_hang = 0;
    self->num_of_speech = 0;

    // Initialization of downsampling filter state.
    memset(self->downsampling_filter_states, 0, sizeof(self->downsampling_filter_states));

    // Initialization of 48 to 8 kHz downsampling.
    WebRtcSpl_ResetResample48khzTo8khz(&self->state_48_to_8);

    // Read initial PDF parameters.
    for (i = 0; i < kTableSize; i++) {
        self->noise_means[i] = kNoiseDataMeans[i];
        self->speech_means[i] = kSpeechDataMeans[i];
        self->noise_stds[i] = kNoiseDataStds[i];
        self->speech_stds[i] = kSpeechDataStds[i];
    }

    // Initialize Index and Minimum value vectors.
    for (i = 0; i < 16 * kNumChannels; i++) {
        self->low_value_vector[i] = 10000;
        self->index_vector[i] = 0;
    }

    // Initialize splitting filter states.
    memset(self->upper_state, 0, sizeof(self->upper_state));
    memset(self->lower_state, 0, sizeof(self->lower_state));

    // Initialize high pass filter states.
    memset(self->hp_filter_state, 0, sizeof(self->hp_filter_state));

    // Initialize mean value memory, for WebRtcVad_FindMinimum().
    for (i = 0; i < kNumChannels; i++) {
        self->mean_value[i] = 1600;
    }

    // Set aggressiveness mode to default (=|kDefaultMode|).
    if (WebRtcVad_set_mode_core(self, kDefaultMode) != 0) {
        return -1;
    }

    self->init_flag = kInitCheck;

    return 0;
}

// Set aggressiveness mode
int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
    int return_value = 0;

    switch (mode) {
        case 0:
            // Quality mode.
            memcpy(self->over_hang_max_1, kOverHangMax1Q, sizeof(self->over_hang_max_1));
            memcpy(self->over_hang_max_2, kOverHangMax2Q, sizeof(self->over_hang_max_2));
            memcpy(self->individual, kLocalThresholdQ, sizeof(self->individual));
            memcpy(self->total, kGlobalThresholdQ, sizeof(self->total));
            break;
        case 1:
            // Low bitrate mode.
            memcpy(self->over_hang_max_1, kOverHangMax1LBR, sizeof(self->over_hang_max_1));
            memcpy(self->over_hang_max_2, kOverHangMax2LBR, sizeof(self->over_hang_max_2));
            memcpy(self->individual, kLocalThresholdLBR, sizeof(self->individual));
            memcpy(self->total, kGlobalThresholdLBR, sizeof(self->total));
            break;
        case 2:
            // Aggressive mode.
            memcpy(self->over_hang_max_1, kOverHangMax1AGG, sizeof(self->over_hang_max_1));
            memcpy(self->over_hang_max_2, kOverHangMax2AGG, sizeof(self->over_hang_max_2));
            memcpy(self->individual, kLocalThresholdAGG, sizeof(self->individual));
            memcpy(self->total, kGlobalThresholdAGG, sizeof(self->total));
            break;
        case 3:
            // Very aggressive mode.
            memcpy(self->over_hang_max_1, kOverHangMax1VAG, sizeof(self->over_hang_max_1));
            memcpy(self->over_hang_max_2, kOverHangMax2VAG, sizeof(self->over_hang_max_2));
            memcpy(self->individual, kLocalThresholdVAG, sizeof(self->individual));
            memcpy(self->total, kGlobalThresholdVAG, sizeof(self->total));
            break;
        default:
            return_value = -1;
            break;
    }

    return return_value;
}

// Calculate VAD decision by first extracting feature values and then calculate
// probability for both speech and background noise.

int WebRtcVad_CalcVad48khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length) {
    int vad;
    size_t i;
    int16_t speech_nb[240];  // 30 ms in 8 kHz.
    // |tmp_mem| is a temporary memory used by resample function, length is
    // frame length in 10 ms (480 samples) + 256 extra.
    int32_t tmp_mem[480 + 256] = {0};
    const size_t kFrameLen10ms48khz = 480;
    const size_t kFrameLen10ms8khz = 80;
    size_t num_10ms_frames = frame_length / kFrameLen10ms48khz;

    for (i = 0; i < num_10ms_frames; i++) {
        WebRtcSpl_Resample48khzTo8khz(speech_frame, &speech_nb[i * kFrameLen10ms8khz], &inst->state_48_to_8, tmp_mem);
    }

    // Do VAD on an 8 kHz signal
    vad = WebRtcVad_CalcVad8khz(inst, speech_nb, frame_length / 6);

    return vad;
}

int WebRtcVad_CalcVad32khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length) {
    size_t len;
    int vad;
    int16_t speechWB[480];  // Downsampled speech frame: 960 samples (30ms in SWB)
    int16_t speechNB[240];  // Downsampled speech frame: 480 samples (30ms in WB)


    // Downsample signal 32->16->8 before doing VAD
    WebRtcVad_Downsampling(speech_frame, speechWB, &(inst->downsampling_filter_states[2]), frame_length);
    len = frame_length / 2;

    WebRtcVad_Downsampling(speechWB, speechNB, inst->downsampling_filter_states, len);
    len /= 2;

    // Do VAD on an 8 kHz signal
    vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);

    return vad;
}

int WebRtcVad_CalcVad16khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length) {
    size_t len;
    int vad;
    int16_t speechNB[240];  // Downsampled speech frame: 480 samples (30ms in WB)

    // Wideband: Downsample signal before doing VAD
    WebRtcVad_Downsampling(speech_frame, speechNB, inst->downsampling_filter_states, frame_length);

    len = frame_length / 2;
    vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);

    return vad;
}

int WebRtcVad_CalcVad8khz(VadInstT* inst, const int16_t* speech_frame, size_t frame_length) {
    int16_t feature_vector[kNumChannels], total_power;

    // Get power in the bands
    total_power = WebRtcVad_CalculateFeatures(inst, speech_frame, frame_length, feature_vector);

    // Make a VAD
    inst->vad = GmmProbability(inst, feature_vector, total_power, frame_length);

    return inst->vad;
}
}  // namespace webrtc
#endif",16171,True,3038.935676761823,median
"/* This is the contributed code:

File:             cvcap_v4l.cpp
Current Location: ../opencv-0.9.6/otherlibs/highgui

Original Version: 2003-03-12  Magnus Lundin lundin@mlu.mine.nu
Original Comments:

ML:This set of files adds support for firevre and usb cameras.
First it tries to install a firewire camera,
if that fails it tries a v4l/USB camera
It has been tested with the motempl sample program

First Patch:  August 24, 2004 Travis Wood   TravisOCV@tkwood.com
For Release:  OpenCV-Linux Beta4  opencv-0.9.6
Tested On:    LMLBT44 with 8 video inputs
Problems?     Post your questions at answers.opencv.org,
              Report bugs at code.opencv.org,
              Submit your fixes at https://github.com/Itseez/opencv/
Patched Comments:

TW: The cv cam utils that came with the initial release of OpenCV for LINUX Beta4
were not working.  I have rewritten them so they work for me. At the same time, trying
to keep the original code as ML wrote it as unchanged as possible.  No one likes to debug
someone elses code, so I resisted changes as much as possible.  I have tried to keep the
same ""ideas"" where applicable, that is, where I could figure out what the previous author
intended. Some areas I just could not help myself and had to ""spiffy-it-up"" my way.

These drivers should work with other V4L frame capture cards other then my bttv
driven frame capture card.

Re Written driver for standard V4L mode. Tested using LMLBT44 video capture card.
Standard bttv drivers are on the LMLBT44 with up to 8 Inputs.

This utility was written with the help of the document:
http://pages.cpsc.ucalgary.ca/~sayles/VFL_HowTo
as a general guide for interfacing into the V4l standard.

Made the index value passed for icvOpenCAM_V4L(index) be the number of the
video device source in the /dev tree. The -1 uses original /dev/video.

Index  Device
  0    /dev/video0
  1    /dev/video1
  2    /dev/video2
  3    /dev/video3
  ...
  7    /dev/video7
with
  -1   /dev/video

TW: You can select any video source, but this package was limited from the start to only
ONE camera opened at any ONE time.
This is an original program limitation.
If you are interested, I will make my version available to other OpenCV users.  The big
difference in mine is you may pass the camera number as part of the cv argument, but this
convention is non standard for current OpenCV calls and the camera number is not currently
passed into the called routine.

Second Patch:   August 28, 2004 Sfuncia Fabio fiblan@yahoo.it
For Release:  OpenCV-Linux Beta4 Opencv-0.9.6

FS: this patch fix not sequential index of device (unplugged device), and real numCameras.
    for -1 index (icvOpenCAM_V4L) i dont use /dev/video but real device available, because
    if /dev/video is a link to /dev/video0 and i unplugged device on /dev/video0, /dev/video
    is a bad link. I search the first available device with indexList.

Third Patch:   December 9, 2004 Frederic Devernay Frederic.Devernay@inria.fr
For Release:  OpenCV-Linux Beta4 Opencv-0.9.6

[FD] I modified the following:
 - handle YUV420P, YUV420, and YUV411P palettes (for many webcams) without using floating-point
 - cvGrabFrame should not wait for the end of the first frame, and should return quickly
   (see highgui doc)
 - cvRetrieveFrame should in turn wait for the end of frame capture, and should not
   trigger the capture of the next frame (the user choses when to do it using GrabFrame)
   To get the old behavior, re-call cvRetrieveFrame just after cvGrabFrame.
 - having global bufferIndex and FirstCapture variables makes the code non-reentrant
 (e.g. when using several cameras), put these in the CvCapture struct.
 - according to V4L HowTo, incrementing the buffer index must be done before VIDIOCMCAPTURE.
 - the VID_TYPE_SCALES stuff from V4L HowTo is wrong: image size can be changed
   even if the hardware does not support scaling (e.g. webcams can have several
   resolutions available). Just don't try to set the size at 640x480 if the hardware supports
   scaling: open with the default (probably best) image size, and let the user scale it
   using SetProperty.
 - image size can be changed by two subsequent calls to SetProperty (for width and height)
 - bug fix: if the image size changes, realloc the new image only when it is grabbed
 - issue errors only when necessary, fix error message formatting.

Fourth Patch: Sept 7, 2005 Csaba Kertesz sign@freemail.hu
For Release:  OpenCV-Linux Beta5 OpenCV-0.9.7

I modified the following:
  - Additional Video4Linux2 support :)
  - Use mmap functions (v4l2)
  - New methods are internal:
    try_palette_v4l2 -> rewrite try_palette for v4l2
    mainloop_v4l2, read_image_v4l2 -> this methods are moved from official v4l2 capture.c example
    try_init_v4l -> device v4l initialisation
    try_init_v4l2 -> device v4l2 initialisation
    autosetup_capture_mode_v4l -> autodetect capture modes for v4l
    autosetup_capture_mode_v4l2 -> autodetect capture modes for v4l2
  - Modifications are according with Video4Linux old codes
  - Video4Linux handling is automatically if it does not recognize a Video4Linux2 device
  - Tested successfully with Logitech Quickcam Express (V4L), Creative Vista (V4L) and Genius VideoCam Notebook (V4L2)
  - Correct source lines with compiler warning messages
  - Information message from v4l/v4l2 detection

Fifth Patch: Sept 7, 2005 Csaba Kertesz sign@freemail.hu
For Release:  OpenCV-Linux Beta5 OpenCV-0.9.7

I modified the following:
  - SN9C10x chip based webcams support
  - New methods are internal:
    bayer2rgb24, sonix_decompress -> decoder routines for SN9C10x decoding from Takafumi Mizuno <taka-qce@ls-a.jp> with his pleasure :)
  - Tested successfully with Genius VideoCam Notebook (V4L2)

Sixth Patch: Sept 10, 2005 Csaba Kertesz sign@freemail.hu
For Release:  OpenCV-Linux Beta5 OpenCV-0.9.7

I added the following:
  - Add capture control support (hue, saturation, brightness, contrast, gain)
  - Get and change V4L capture controls (hue, saturation, brightness, contrast)
  - New method is internal:
    icvSetControl -> set capture controls
  - Tested successfully with Creative Vista (V4L)

Seventh Patch: Sept 10, 2005 Csaba Kertesz sign@freemail.hu
For Release:  OpenCV-Linux Beta5 OpenCV-0.9.7

I added the following:
  - Detect, get and change V4L2 capture controls (hue, saturation, brightness, contrast, gain)
  - New methods are internal:
    v4l2_scan_controls_enumerate_menu, v4l2_scan_controls -> detect capture control intervals
  - Tested successfully with Genius VideoCam Notebook (V4L2)

8th patch: Jan 5, 2006, Olivier.Bornet@idiap.ch
Add support of V4L2_PIX_FMT_YUYV and V4L2_PIX_FMT_MJPEG.
With this patch, new webcams of Logitech, like QuickCam Fusion works.
Note: For use these webcams, look at the UVC driver at
http://linux-uvc.berlios.de/

9th patch: Mar 4, 2006, Olivier.Bornet@idiap.ch
- try V4L2 before V4L, because some devices are V4L2 by default,
  but they try to implement the V4L compatibility layer.
  So, I think this is better to support V4L2 before V4L.
- better separation between V4L2 and V4L initialization. (this was needed to support
  some drivers working, but not fully with V4L2. (so, we do not know when we
  need to switch from V4L2 to V4L.

10th patch: July 02, 2008, Mikhail Afanasyev fopencv@theamk.com
Fix reliability problems with high-resolution UVC cameras on linux
the symptoms were damaged image and 'Corrupt JPEG data: premature end of data segment' on stderr
- V4L_ABORT_BADJPEG detects JPEG warnings and turns them into errors, so bad images
  could be filtered out
- USE_TEMP_BUFFER fixes the main problem (improper buffer management) and
  prevents bad images in the first place

11th patch: Apr 13, 2010, Filipe Almeida filipe.almeida@ist.utl.pt
- Tries to setup all properties first through v4l2_ioctl call.
- Allows setting up all Video4Linux properties through cvSetCaptureProperty instead of only CV_CAP_PROP_BRIGHTNESS, CV_CAP_PROP_CONTRAST, CV_CAP_PROP_SATURATION, CV_CAP_PROP_HUE, CV_CAP_PROP_GAIN and CV_CAP_PROP_EXPOSURE.

12th patch: Apr 16, 2010, Filipe Almeida filipe.almeida@ist.utl.pt
- CvCaptureCAM_V4L structure cleanup (no longer needs <PROPERTY>_{min,max,} variables)
- Introduction of v4l2_ctrl_range - minimum and maximum allowed values for v4l controls
- Allows setting up all Video4Linux properties through cvSetCaptureProperty using input values between 0.0 and 1.0
- Gets v4l properties first through v4l2_ioctl call (ignores capture->is_v4l2_device)
- cvGetCaptureProperty adjusted to support the changes
- Returns device properties to initial values after device closes

13th patch: Apr 27, 2010, Filipe Almeida filipe.almeida@ist.utl.pt
- Solved problem mmaping the device using uvcvideo driver (use o v4l2_mmap instead of mmap)
make & enjoy!

14th patch: May 10, 2010, Filipe Almeida filipe.almeida@ist.utl.pt
- Bug #142: Solved/Workaround ""setting frame width and height does not work""
  There was a problem setting up the size when the input is a v4l2 device
  The workaround closes the camera and reopens it with the new definition
  Planning for future rewrite of this whole library (July/August 2010)

15th patch: May 12, 2010, Filipe Almeida filipe.almeida@ist.utl.pt
- Broken compile of library (include ""_highgui.h"")
*/

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's 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.
//
//   * The name of Intel Corporation may not 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 Intel Corporation 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.
//
//M*/

#include ""precomp.hpp""

#if !defined WIN32 && defined HAVE_LIBV4L

#define CLEAR(x) memset (&(x), 0, sizeof (x))

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <string.h>
#include <stdlib.h>
#include <asm/types.h>          /* for videodev2.h */
#include <assert.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

#ifdef HAVE_CAMV4L
#include <linux/videodev.h>
#endif
#ifdef HAVE_CAMV4L2
#include <linux/videodev2.h>
#endif

#include <libv4l1.h>
#include <libv4l2.h>

/* Defaults - If your board can do better, set it here.  Set for the most common type inputs. */
#define DEFAULT_V4L_WIDTH  640
#define DEFAULT_V4L_HEIGHT 480

#define CHANNEL_NUMBER 1
#define MAX_CAMERAS 8


// default and maximum number of V4L buffers, not including last, 'special' buffer
#define MAX_V4L_BUFFERS 10
#define DEFAULT_V4L_BUFFERS 4

// if enabled, copies data from the buffer. this uses a bit more memory,
//  but much more reliable for some UVC cameras
#define USE_TEMP_BUFFER

#define MAX_DEVICE_DRIVER_NAME 80

/* Device Capture Objects */
/* V4L2 structure */
struct buffer
{
  void *  start;
  size_t  length;
};
static unsigned int n_buffers = 0;

/* TODO: Dilemas: */
/* TODO: Consider drop the use of this data structure and perform ioctl to obtain needed values */
/* TODO: Consider at program exit return controls to the initial values - See v4l2_free_ranges function */
/* TODO: Consider at program exit reset the device to default values - See v4l2_free_ranges function */
typedef struct v4l2_ctrl_range {
  __u32 ctrl_id;
  __s32 initial_value;
  __s32 current_value;
  __s32 minimum;
  __s32 maximum;
  __s32 default_value;
} v4l2_ctrl_range;

typedef struct CvCaptureCAM_V4L
{
    char* deviceName;
    int deviceHandle;
    int bufferIndex;
    int FirstCapture;

    int width; int height;

    struct video_capability capability;
    struct video_window     captureWindow;
    struct video_picture    imageProperties;
    struct video_mbuf       memoryBuffer;
    struct video_mmap       *mmaps;
    char *memoryMap;
    IplImage frame;

   /* V4L2 variables */
   buffer buffers[MAX_V4L_BUFFERS + 1];
   struct v4l2_capability cap;
   struct v4l2_input inp;
   struct v4l2_format form;
   struct v4l2_crop crop;
   struct v4l2_cropcap cropcap;
   struct v4l2_requestbuffers req;
   struct v4l2_jpegcompression compr;
   struct v4l2_control control;
   enum v4l2_buf_type type;
   struct v4l2_queryctrl queryctrl;

   /* V4L2 control variables */
   v4l2_ctrl_range** v4l2_ctrl_ranges;
   int v4l2_ctrl_count;

   int is_v4l2_device;
}
CvCaptureCAM_V4L;

static void icvCloseCAM_V4L( CvCaptureCAM_V4L* capture );

static int icvGrabFrameCAM_V4L( CvCaptureCAM_V4L* capture );
static IplImage* icvRetrieveFrameCAM_V4L( CvCaptureCAM_V4L* capture, int );
CvCapture* cvCreateCameraCapture_V4L( int index );

static double icvGetPropertyCAM_V4L( CvCaptureCAM_V4L* capture, int property_id );
static int    icvSetPropertyCAM_V4L( CvCaptureCAM_V4L* capture, int property_id, double value );

static int icvSetVideoSize( CvCaptureCAM_V4L* capture, int w, int h);

/***********************   Implementations  ***************************************/

static int numCameras = 0;
static int indexList = 0;

// IOCTL handling for V4L2
#ifdef HAVE_IOCTL_ULONG
static int xioctl( int fd, unsigned long request, void *arg)
#else
static int xioctl( int fd, int request, void *arg)
#endif
{

  int r;


  do r = v4l2_ioctl (fd, request, arg);
  while (-1 == r && EINTR == errno);

  return r;

}


/* Simple test program: Find number of Video Sources available.
   Start from 0 and go to MAX_CAMERAS while checking for the device with that name.
   If it fails on the first attempt of /dev/video0, then check if /dev/video is valid.
   Returns the global numCameras with the correct value (we hope) */

static void icvInitCapture_V4L() {
   int deviceHandle;
   int CameraNumber;
   char deviceName[MAX_DEVICE_DRIVER_NAME];

   CameraNumber = 0;
   while(CameraNumber < MAX_CAMERAS) {
      /* Print the CameraNumber at the end of the string with a width of one character */
      sprintf(deviceName, ""/dev/video%1d"", CameraNumber);
      /* Test using an open to see if this new device name really does exists. */
      deviceHandle = open(deviceName, O_RDONLY);
      if (deviceHandle != -1) {
         /* This device does indeed exist - add it to the total so far */
    // add indexList
    indexList|=(1 << CameraNumber);
        numCameras++;
    }
    if (deviceHandle != -1)
      close(deviceHandle);
      /* Set up to test the next /dev/video source in line */
      CameraNumber++;
   } /* End while */

}; /* End icvInitCapture_V4L */


static int try_init_v4l(CvCaptureCAM_V4L* capture, char *deviceName)

{

  // if detect = -1 then unable to open device
  // if detect = 0 then detected nothing
  // if detect = 1 then V4L device
  int detect = 0;


  // Test device for V4L compability

  /* Test using an open to see if this new device name really does exists. */
  /* No matter what the name - it still must be opened! */
  capture->deviceHandle = v4l1_open(deviceName, O_RDWR);


  if (capture->deviceHandle == 0)
  {
    detect = -1;

    icvCloseCAM_V4L(capture);
  }

  if (detect == 0)
  {
    /* Query the newly opened device for its capabilities */
    if (v4l1_ioctl(capture->deviceHandle, VIDIOCGCAP, &capture->capability) < 0)
    {
      detect = 0;

      icvCloseCAM_V4L(capture);
    }
      else
    {
      detect = 1;
    }
  }

  return detect;

}


static int try_init_v4l2(CvCaptureCAM_V4L* capture, char *deviceName)
{

  // if detect = -1 then unable to open device
  // if detect = 0 then detected nothing
  // if detect = 1 then V4L2 device
  int detect = 0;


  // Test device for V4L2 compability

  /* Open and test V4L2 device */
  capture->deviceHandle = v4l2_open (deviceName, O_RDWR /* required */ | O_NONBLOCK, 0);



  if (capture->deviceHandle == 0)
  {
    detect = -1;

    icvCloseCAM_V4L(capture);
  }

  if (detect == 0)
  {
    CLEAR (capture->cap);
    if (-1 == xioctl (capture->deviceHandle, VIDIOC_QUERYCAP, &capture->cap))
    {
      detect = 0;

      icvCloseCAM_V4L(capture);
    }
      else
    {
      CLEAR (capture->capability);
      capture->capability.type = capture->cap.capabilities;

      /* Query channels number */
      if (-1 != xioctl (capture->deviceHandle, VIDIOC_G_INPUT, &capture->capability.channels))
      {
        detect = 1;
      }
    }
  }

  return detect;

}


static void v4l2_free_ranges(CvCaptureCAM_V4L* capture) {
  int i;
  if (capture->v4l2_ctrl_ranges != NULL) {
    for (i = 0; i < capture->v4l2_ctrl_count; i++) {
      /* Return device to initial values: */
      /* double value = (capture->v4l2_ctrl_ranges[i]->initial_value == 0)?0.0:((float)capture->v4l2_ctrl_ranges[i]->initial_value - capture->v4l2_ctrl_ranges[i]->minimum) / (capture->v4l2_ctrl_ranges[i]->maximum - capture->v4l2_ctrl_ranges[i]->minimum); */
      /* Return device to default values: */
      /* double value = (capture->v4l2_ctrl_ranges[i]->default_value == 0)?0.0:((float)capture->v4l2_ctrl_ranges[i]->default_value - capture->v4l2_ctrl_ranges[i]->minimum + 1) / (capture->v4l2_ctrl_ranges[i]->maximum - capture->v4l2_ctrl_ranges[i]->minimum); */

      /* icvSetPropertyCAM_V4L(capture, capture->v4l2_ctrl_ranges[i]->ctrl_id, value); */
      free(capture->v4l2_ctrl_ranges[i]);
    }
  }
  free(capture->v4l2_ctrl_ranges);
  capture->v4l2_ctrl_count  = 0;
  capture->v4l2_ctrl_ranges = NULL;
}

static void v4l2_add_ctrl_range(CvCaptureCAM_V4L* capture, v4l2_control* ctrl) {
  v4l2_ctrl_range* range    = (v4l2_ctrl_range*)malloc(sizeof(v4l2_ctrl_range));
  range->ctrl_id            = ctrl->id;
  range->initial_value      = ctrl->value;
  range->current_value      = ctrl->value;
  range->minimum            = capture->queryctrl.minimum;
  range->maximum            = capture->queryctrl.maximum;
  range->default_value      = capture->queryctrl.default_value;
  capture->v4l2_ctrl_ranges[capture->v4l2_ctrl_count] = range;
  capture->v4l2_ctrl_count += 1;
  capture->v4l2_ctrl_ranges = (v4l2_ctrl_range**)realloc((v4l2_ctrl_range**)capture->v4l2_ctrl_ranges, (capture->v4l2_ctrl_count + 1) * sizeof(v4l2_ctrl_range*));
}

static int v4l2_get_ctrl_default(CvCaptureCAM_V4L* capture, __u32 id) {
  int i;
  for (i = 0; i < capture->v4l2_ctrl_count; i++) {
    if (id == capture->v4l2_ctrl_ranges[i]->ctrl_id) {
      return capture->v4l2_ctrl_ranges[i]->default_value;
    }
  }
  return -1;
}

static int v4l2_get_ctrl_min(CvCaptureCAM_V4L* capture, __u32 id) {
  int i;
  for (i = 0; i < capture->v4l2_ctrl_count; i++) {
    if (id == capture->v4l2_ctrl_ranges[i]->ctrl_id) {
      return capture->v4l2_ctrl_ranges[i]->minimum;
    }
  }
  return -1;
}

static int v4l2_get_ctrl_max(CvCaptureCAM_V4L* capture, __u32 id) {
  int i;
  for (i = 0; i < capture->v4l2_ctrl_count; i++) {
    if (id == capture->v4l2_ctrl_ranges[i]->ctrl_id) {
      return capture->v4l2_ctrl_ranges[i]->maximum;
    }
  }
  return -1;
}


static void v4l2_scan_controls(CvCaptureCAM_V4L* capture) {

  __u32 ctrl_id;
  struct v4l2_control c;
  if (capture->v4l2_ctrl_ranges != NULL) {
    v4l2_free_ranges(capture);
  }
  capture->v4l2_ctrl_ranges = (v4l2_ctrl_range**)malloc(sizeof(v4l2_ctrl_range*));
#ifdef V4L2_CTRL_FLAG_NEXT_CTRL
  /* Try the extended control API first */
  capture->queryctrl.id      = V4L2_CTRL_FLAG_NEXT_CTRL;
  if(0 == v4l2_ioctl (capture->deviceHandle, VIDIOC_QUERYCTRL, &capture->queryctrl)) {
    do {
      c.id = capture->queryctrl.id;
      capture->queryctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
      if(capture->queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
        continue;
      }
      if(capture->queryctrl.type != V4L2_CTRL_TYPE_INTEGER &&
         capture->queryctrl.type != V4L2_CTRL_TYPE_BOOLEAN &&
         capture->queryctrl.type != V4L2_CTRL_TYPE_MENU) {
        continue;
      }
      if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &c) == 0) {
        v4l2_add_ctrl_range(capture, &c);
      }

    } while(0 == v4l2_ioctl (capture->deviceHandle, VIDIOC_QUERYCTRL, &capture->queryctrl));
  } else
#endif
  {
    /* Check all the standard controls */
    for(ctrl_id=V4L2_CID_BASE; ctrl_id<V4L2_CID_LASTP1; ctrl_id++) {
      capture->queryctrl.id = ctrl_id;
      if(v4l2_ioctl(capture->deviceHandle, VIDIOC_QUERYCTRL, &capture->queryctrl) == 0) {
        if(capture->queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
          continue;
        }
        if(capture->queryctrl.type != V4L2_CTRL_TYPE_INTEGER &&
           capture->queryctrl.type != V4L2_CTRL_TYPE_BOOLEAN &&
           capture->queryctrl.type != V4L2_CTRL_TYPE_MENU) {
          continue;
        }
        c.id = ctrl_id;

        if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &c) == 0) {
          v4l2_add_ctrl_range(capture, &c);
        }
      }
    }

    /* Check any custom controls */
    for(ctrl_id=V4L2_CID_PRIVATE_BASE; ; ctrl_id++) {
      capture->queryctrl.id = ctrl_id;
      if(v4l2_ioctl(capture->deviceHandle, VIDIOC_QUERYCTRL, &capture->queryctrl) == 0) {
        if(capture->queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
          continue;
        }


        if(capture->queryctrl.type != V4L2_CTRL_TYPE_INTEGER &&
           capture->queryctrl.type != V4L2_CTRL_TYPE_BOOLEAN &&
           capture->queryctrl.type != V4L2_CTRL_TYPE_MENU) {
           continue;
        }

        c.id = ctrl_id;

        if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &c) == 0) {
          v4l2_add_ctrl_range(capture, &c);
        }
      } else {
        break;
      }
    }
  }
}

static int _capture_V4L2 (CvCaptureCAM_V4L *capture, char *deviceName)
{
   int detect_v4l2 = 0;

   capture->deviceName = strdup(deviceName);

   detect_v4l2 = try_init_v4l2(capture, deviceName);

   if (detect_v4l2 != 1) {
       /* init of the v4l2 device is not OK */
       return -1;
   }

   /* starting from here, we assume we are in V4L2 mode */
   capture->is_v4l2_device = 1;

   capture->v4l2_ctrl_ranges = NULL;
   capture->v4l2_ctrl_count = 0;

   /* Scan V4L2 controls */
   v4l2_scan_controls(capture);

   if ((capture->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
      /* Nope. */
      fprintf( stderr, ""HIGHGUI ERROR: V4L2: device %s is unable to capture video memory.\\n"",deviceName);
      icvCloseCAM_V4L(capture);
      return -1;
   }

   /* The following code sets the CHANNEL_NUMBER of the video input.  Some video sources
   have sub ""Channel Numbers"".  For a typical V4L TV capture card, this is usually 1.
   I myself am using a simple NTSC video input capture card that uses the value of 1.
   If you are not in North America or have a different video standard, you WILL have to change
   the following settings and recompile/reinstall.  This set of settings is based on
   the most commonly encountered input video source types (like my bttv card) */

   if(capture->inp.index > 0) {
       CLEAR (capture->inp);
       capture->inp.index = CHANNEL_NUMBER;
       /* Set only channel number to CHANNEL_NUMBER */
       /* V4L2 have a status field from selected video mode */
       if (-1 == xioctl (capture->deviceHandle, VIDIOC_ENUMINPUT, &capture->inp))
       {
         fprintf (stderr, ""HIGHGUI ERROR: V4L2: Aren't able to set channel number\\n"");
         icvCloseCAM_V4L (capture);
         return -1;
       }
   } /* End if */

   /* Find Window info */
   CLEAR (capture->form);
   capture->form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

   if (-1 == xioctl (capture->deviceHandle, VIDIOC_G_FMT, &capture->form)) {
       fprintf( stderr, ""HIGHGUI ERROR: V4L2: Could not obtain specifics of capture window.\\n\\n"");
       icvCloseCAM_V4L(capture);
       return -1;
   }

  /* libv4l will convert from any format to V4L2_PIX_FMT_BGR24 */
  CLEAR (capture->form);
  capture->form.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  capture->form.fmt.pix.pixelformat = V4L2_PIX_FMT_BGR24;
  capture->form.fmt.pix.field       = V4L2_FIELD_ANY;
  capture->form.fmt.pix.width = capture->width;
  capture->form.fmt.pix.height = capture->height;

  if (-1 == xioctl (capture->deviceHandle, VIDIOC_S_FMT, &capture->form)) {
      fprintf(stderr, ""HIGHGUI ERROR: libv4l unable to ioctl S_FMT\\n"");
      return -1;
  }

  if (V4L2_PIX_FMT_BGR24 != capture->form.fmt.pix.pixelformat) {
      fprintf( stderr, ""HIGHGUI ERROR: libv4l unable convert to requested pixfmt\\n"");
      return -1;
  }

   /* icvSetVideoSize(capture, DEFAULT_V4L_WIDTH, DEFAULT_V4L_HEIGHT); */

   unsigned int min;

   /* Buggy driver paranoia. */
   min = capture->form.fmt.pix.width * 2;

   if (capture->form.fmt.pix.bytesperline < min)
       capture->form.fmt.pix.bytesperline = min;

   min = capture->form.fmt.pix.bytesperline * capture->form.fmt.pix.height;

   if (capture->form.fmt.pix.sizeimage < min)
       capture->form.fmt.pix.sizeimage = min;

   CLEAR (capture->req);

   unsigned int buffer_number = DEFAULT_V4L_BUFFERS;

   try_again:

   capture->req.count = buffer_number;
   capture->req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   capture->req.memory = V4L2_MEMORY_MMAP;

   if (-1 == xioctl (capture->deviceHandle, VIDIOC_REQBUFS, &capture->req))
   {
       if (EINVAL == errno)
       {
         fprintf (stderr, ""%s does not support memory mapping\\n"", deviceName);
       } else {
         perror (""VIDIOC_REQBUFS"");
       }
       /* free capture, and returns an error code */
       icvCloseCAM_V4L (capture);
       return -1;
   }

   if (capture->req.count < buffer_number)
   {
       if (buffer_number == 1)
       {
           fprintf (stderr, ""Insufficient buffer memory on %s\\n"", deviceName);

           /* free capture, and returns an error code */
           icvCloseCAM_V4L (capture);
           return -1;
       } else {
         buffer_number--;
   fprintf (stderr, ""Insufficient buffer memory on %s -- decreaseing buffers\\n"", deviceName);

   goto try_again;
       }
   }

   for (n_buffers = 0; n_buffers < capture->req.count; ++n_buffers)
   {
       struct v4l2_buffer buf;

       CLEAR (buf);

       buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
       buf.memory = V4L2_MEMORY_MMAP;
       buf.index = n_buffers;

       if (-1 == xioctl (capture->deviceHandle, VIDIOC_QUERYBUF, &buf)) {
           perror (""VIDIOC_QUERYBUF"");

           /* free capture, and returns an error code */
           icvCloseCAM_V4L (capture);
           return -1;
       }

       capture->buffers[n_buffers].length = buf.length;
       capture->buffers[n_buffers].start =
         v4l2_mmap (NULL /* start anywhere */,
                    buf.length,
                    PROT_READ | PROT_WRITE /* required */,
                    MAP_SHARED /* recommended */,
                    capture->deviceHandle, buf.m.offset);

       if (MAP_FAILED == capture->buffers[n_buffers].start) {
           perror (""mmap"");

           /* free capture, and returns an error code */
           icvCloseCAM_V4L (capture);
           return -1;
       }

#ifdef USE_TEMP_BUFFER
       if (n_buffers == 0) {
           if (capture->buffers[MAX_V4L_BUFFERS].start) {
               free(capture->buffers[MAX_V4L_BUFFERS].start);
               capture->buffers[MAX_V4L_BUFFERS].start = NULL;
       }

           capture->buffers[MAX_V4L_BUFFERS].start = malloc(buf.length);
           capture->buffers[MAX_V4L_BUFFERS].length = buf.length;
       };
#endif
   }

   /* Set up Image data */
   cvInitImageHeader( &capture->frame,
                      cvSize( capture->captureWindow.width,
                              capture->captureWindow.height ),
                      IPL_DEPTH_8U, 3, IPL_ORIGIN_TL, 4 );
   /* Allocate space for RGBA data */
   capture->frame.imageData = (char *)cvAlloc(capture->frame.imageSize);

   return 1;
}; /* End _capture_V4L2 */


static int _capture_V4L (CvCaptureCAM_V4L *capture, char *deviceName)
{
   int detect_v4l = 0;

   detect_v4l = try_init_v4l(capture, deviceName);

   if (detect_v4l == -1)
   {
     fprintf (stderr, ""HIGHGUI ERROR: V4L""
              "": device %s: Unable to open for READ ONLY\\n"", deviceName);

     return -1;
   }

   if (detect_v4l <= 0)
   {
     fprintf (stderr, ""HIGHGUI ERROR: V4L""
              "": device %s: Unable to query number of channels\\n"", deviceName);

     return -1;
   }

   {
     if ((capture->capability.type & VID_TYPE_CAPTURE) == 0) {
       /* Nope. */
       fprintf( stderr, ""HIGHGUI ERROR: V4L: ""
                ""device %s is unable to capture video memory.\\n"",deviceName);
       icvCloseCAM_V4L(capture);
       return -1;
     }

   }


   /* The following code sets the CHANNEL_NUMBER of the video input.  Some video sources
   have sub ""Channel Numbers"".  For a typical V4L TV capture card, this is usually 1.
   I myself am using a simple NTSC video input capture card that uses the value of 1.
   If you are not in North America or have a different video standard, you WILL have to change
   the following settings and recompile/reinstall.  This set of settings is based on
   the most commonly encountered input video source types (like my bttv card) */

   {

     if(capture->capability.channels>0) {

       struct video_channel selectedChannel;

       selectedChannel.channel=CHANNEL_NUMBER;
       if (v4l1_ioctl(capture->deviceHandle, VIDIOCGCHAN , &selectedChannel) != -1) {
          /* set the video mode to ( VIDEO_MODE_PAL, VIDEO_MODE_NTSC, VIDEO_MODE_SECAM) */
//           selectedChannel.norm = VIDEO_MODE_NTSC;
          if (v4l1_ioctl(capture->deviceHandle, VIDIOCSCHAN , &selectedChannel) == -1) {
             /* Could not set selected channel - Oh well */
             //printf(""\\n%d, %s not NTSC capable.\\n"",selectedChannel.channel, selectedChannel.name);
          } /* End if */
       } /* End if */
     } /* End if */

   }

   {

     if(v4l1_ioctl(capture->deviceHandle, VIDIOCGWIN, &capture->captureWindow) == -1) {
       fprintf( stderr, ""HIGHGUI ERROR: V4L: ""
                ""Could not obtain specifics of capture window.\\n\\n"");
       icvCloseCAM_V4L(capture);
       return -1;
     }

   }

   {
      if(v4l1_ioctl(capture->deviceHandle, VIDIOCGPICT, &capture->imageProperties) < 0) {
         fprintf( stderr, ""HIGHGUI ERROR: V4L: Unable to determine size of incoming image\\n"");
         icvCloseCAM_V4L(capture);
         return -1;
      }

      capture->imageProperties.palette = VIDEO_PALETTE_RGB24;
      capture->imageProperties.depth = 24;
      if (v4l1_ioctl(capture->deviceHandle, VIDIOCSPICT, &capture->imageProperties) < 0) {
        fprintf( stderr, ""HIGHGUI ERROR: libv4l unable to ioctl VIDIOCSPICT\\n\\n"");
         icvCloseCAM_V4L(capture);
        return -1;
      }
      if (v4l1_ioctl(capture->deviceHandle, VIDIOCGPICT, &capture->imageProperties) < 0) {
        fprintf( stderr, ""HIGHGUI ERROR: libv4l unable to ioctl VIDIOCGPICT\\n\\n"");
         icvCloseCAM_V4L(capture);
        return -1;
      }
      if (capture->imageProperties.palette != VIDEO_PALETTE_RGB24) {
        fprintf( stderr, ""HIGHGUI ERROR: libv4l unable convert to requested pixfmt\\n\\n"");
         icvCloseCAM_V4L(capture);
        return -1;
      }

   }

   {

     v4l1_ioctl(capture->deviceHandle, VIDIOCGMBUF, &capture->memoryBuffer);
     capture->memoryMap  = (char *)v4l1_mmap(0,
                                   capture->memoryBuffer.size,
                                   PROT_READ | PROT_WRITE,
                                   MAP_SHARED,
                                   capture->deviceHandle,
                                   0);
     if (capture->memoryMap == MAP_FAILED) {
        fprintf( stderr, ""HIGHGUI ERROR: V4L: Mapping Memmory from video source error: %s\\n"", strerror(errno));
        icvCloseCAM_V4L(capture);
        return -1;
     }

     /* Set up video_mmap structure pointing to this memory mapped area so each image may be
        retrieved from an index value */
     capture->mmaps = (struct video_mmap *)
                 (malloc(capture->memoryBuffer.frames * sizeof(struct video_mmap)));
     if (!capture->mmaps) {
        fprintf( stderr, ""HIGHGUI ERROR: V4L: Could not memory map video frames.\\n"");
        icvCloseCAM_V4L(capture);
        return -1;
     }

   }

   /* Set up Image data */
   cvInitImageHeader( &capture->frame,
                      cvSize( capture->captureWindow.width,
                              capture->captureWindow.height ),
                      IPL_DEPTH_8U, 3, IPL_ORIGIN_TL, 4 );
   /* Allocate space for RGBA data */
   capture->frame.imageData = (char *)cvAlloc(capture->frame.imageSize);

   return 1;
}; /* End _capture_V4L */

static CvCaptureCAM_V4L * icvCaptureFromCAM_V4L (int index)
{
   static int autoindex;
   autoindex = 0;

   char deviceName[MAX_DEVICE_DRIVER_NAME];

   if (!numCameras)
      icvInitCapture_V4L(); /* Havent called icvInitCapture yet - do it now! */
   if (!numCameras)
     return NULL; /* Are there any /dev/video input sources? */

   //search index in indexList
   if ( (index>-1) && ! ((1 << index) & indexList) )
   {
     fprintf( stderr, ""HIGHGUI ERROR: V4L: index %d is not correct!\\n"",index);
     return NULL; /* Did someone ask for not correct video source number? */
   }
   /* Allocate memory for this humongus CvCaptureCAM_V4L structure that contains ALL
      the handles for V4L processing */
   CvCaptureCAM_V4L * capture = (CvCaptureCAM_V4L*)cvAlloc(sizeof(CvCaptureCAM_V4L));
   if (!capture) {
      fprintf( stderr, ""HIGHGUI ERROR: V4L: Could not allocate memory for capture process.\\n"");
      return NULL;
   }

#ifdef USE_TEMP_BUFFER
   capture->buffers[MAX_V4L_BUFFERS].start = NULL;
#endif

   /* Select camera, or rather, V4L video source */
   if (index<0) { // Asking for the first device available
     for (; autoindex<MAX_CAMERAS;autoindex++)
    if (indexList & (1<<autoindex))
        break;
     if (autoindex==MAX_CAMERAS)
    return NULL;
     index=autoindex;
     autoindex++;// i can recall icvOpenCAM_V4l with index=-1 for next camera
   }
   /* Print the CameraNumber at the end of the string with a width of one character */
   sprintf(deviceName, ""/dev/video%1d"", index);

   /* w/o memset some parts  arent initialized - AKA: Fill it with zeros so it is clean */
   memset(capture,0,sizeof(CvCaptureCAM_V4L));
   /* Present the routines needed for V4L funtionality.  They are inserted as part of
      the standard set of cv calls promoting transparency.  ""Vector Table"" insertion. */
   capture->FirstCapture = 1;

   /* set the default size */
   capture->width  = DEFAULT_V4L_WIDTH;
   capture->height = DEFAULT_V4L_HEIGHT;

   if (_capture_V4L2 (capture, deviceName) == -1) {
       icvCloseCAM_V4L(capture);
       capture->is_v4l2_device = 0;
       if (_capture_V4L (capture, deviceName) == -1) {
           icvCloseCAM_V4L(capture);
           return NULL;
       }
   } else {
       capture->is_v4l2_device = 1;
   }

   return capture;
}; /* End icvOpenCAM_V4L */

#ifdef HAVE_CAMV4L2

static int read_frame_v4l2(CvCaptureCAM_V4L* capture) {
    struct v4l2_buffer buf;

    CLEAR (buf);

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;

    if (-1 == xioctl (capture->deviceHandle, VIDIOC_DQBUF, &buf)) {
        switch (errno) {
        case EAGAIN:
            return 0;

        case EIO:
            /* Could ignore EIO, see spec. */

            /* fall through */

        default:
            /* display the error and stop processing */
            perror (""VIDIOC_DQBUF"");
            return 1;
        }
   }

   assert(buf.index < capture->req.count);

#ifdef USE_TEMP_BUFFER
   memcpy(capture->buffers[MAX_V4L_BUFFERS].start,
    capture->buffers[buf.index].start,
    capture->buffers[MAX_V4L_BUFFERS].length );
   capture->bufferIndex = MAX_V4L_BUFFERS;
   //printf(""got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\\n"",
   //   buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused);
#else
   capture->bufferIndex = buf.index;
#endif

   if (-1 == xioctl (capture->deviceHandle, VIDIOC_QBUF, &buf))
       perror (""VIDIOC_QBUF"");

   return 1;
}

static void mainloop_v4l2(CvCaptureCAM_V4L* capture) {
    unsigned int count;

    count = 1;

    while (count-- > 0) {
        for (;;) {
            fd_set fds;
            struct timeval tv;
            int r;

            FD_ZERO (&fds);
            FD_SET (capture->deviceHandle, &fds);

            /* Timeout. */
            tv.tv_sec = 10;
            tv.tv_usec = 0;

            r = select (capture->deviceHandle+1, &fds, NULL, NULL, &tv);

            if (-1 == r) {
                if (EINTR == errno)
                    continue;

                perror (""select"");
            }

            if (0 == r) {
                fprintf (stderr, ""select timeout\\n"");

                /* end the infinite loop */
                break;
            }

            if (read_frame_v4l2 (capture))
                break;
        }
    }
}

static int icvGrabFrameCAM_V4L(CvCaptureCAM_V4L* capture) {

   if (capture->FirstCapture) {
      /* Some general initialization must take place the first time through */

      /* This is just a technicality, but all buffers must be filled up before any
         staggered SYNC is applied.  SO, filler up. (see V4L HowTo) */

      if (capture->is_v4l2_device == 1)
      {

        for (capture->bufferIndex = 0;
             capture->bufferIndex < ((int)capture->req.count);
             ++capture->bufferIndex)
        {

          struct v4l2_buffer buf;

          CLEAR (buf);

          buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
          buf.memory      = V4L2_MEMORY_MMAP;
          buf.index       = (unsigned long)capture->bufferIndex;

          if (-1 == xioctl (capture->deviceHandle, VIDIOC_QBUF, &buf)) {
              perror (""VIDIOC_QBUF"");
              return 0;
          }
        }

        /* enable the streaming */
        capture->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if (-1 == xioctl (capture->deviceHandle, VIDIOC_STREAMON,
                          &capture->type)) {
            /* error enabling the stream */
            perror (""VIDIOC_STREAMON"");
            return 0;
        }
      } else
      {

        for (capture->bufferIndex = 0;
         capture->bufferIndex < (capture->memoryBuffer.frames-1);
         ++capture->bufferIndex) {

          capture->mmaps[capture->bufferIndex].frame  = capture->bufferIndex;
          capture->mmaps[capture->bufferIndex].width  = capture->captureWindow.width;
          capture->mmaps[capture->bufferIndex].height = capture->captureWindow.height;
          capture->mmaps[capture->bufferIndex].format = capture->imageProperties.palette;

          if (v4l1_ioctl(capture->deviceHandle, VIDIOCMCAPTURE, &capture->mmaps[capture->bufferIndex]) == -1) {
            fprintf( stderr, ""HIGHGUI ERROR: V4L: Initial Capture Error: Unable to load initial memory buffers.\\n"");
            return 0;
          }
        }

      }

      /* preparation is ok */
      capture->FirstCapture = 0;
   }

   if (capture->is_v4l2_device == 1)
   {

     mainloop_v4l2(capture);

   } else
   {

     capture->mmaps[capture->bufferIndex].frame  = capture->bufferIndex;
     capture->mmaps[capture->bufferIndex].width  = capture->captureWindow.width;
     capture->mmaps[capture->bufferIndex].height = capture->captureWindow.height;
     capture->mmaps[capture->bufferIndex].format = capture->imageProperties.palette;

     if (v4l1_ioctl (capture->deviceHandle, VIDIOCMCAPTURE,
    &capture->mmaps[capture->bufferIndex]) == -1) {
   /* capture is on the way, so just exit */
   return 1;
     }

     ++capture->bufferIndex;
     if (capture->bufferIndex == capture->memoryBuffer.frames) {
        capture->bufferIndex = 0;
     }

   }

   return(1);
}

static IplImage* icvRetrieveFrameCAM_V4L( CvCaptureCAM_V4L* capture, int) {

  if (capture->is_v4l2_device == 0)
  {

    /* [FD] this really belongs here */
    if (v4l1_ioctl(capture->deviceHandle, VIDIOCSYNC, &capture->mmaps[capture->bufferIndex].frame) == -1) {
      fprintf( stderr, ""HIGHGUI ERROR: V4L: Could not SYNC to video stream. %s\\n"", strerror(errno));
    }

  }

   /* Now get what has already been captured as a IplImage return */

   /* First, reallocate imageData if the frame size changed */

  if (capture->is_v4l2_device == 1)
  {

    if(((unsigned long)capture->frame.width != capture->form.fmt.pix.width)
       || ((unsigned long)capture->frame.height != capture->form.fmt.pix.height)) {
        cvFree(&capture->frame.imageData);
        cvInitImageHeader( &capture->frame,
              cvSize( capture->form.fmt.pix.width,
                  capture->form.fmt.pix.height ),
              IPL_DEPTH_8U, 3, IPL_ORIGIN_TL, 4 );
       capture->frame.imageData = (char *)cvAlloc(capture->frame.imageSize);
    }

  } else
  {

    if((capture->frame.width != capture->mmaps[capture->bufferIndex].width)
      || (capture->frame.height != capture->mmaps[capture->bufferIndex].height)) {
       cvFree(&capture->frame.imageData);
       cvInitImageHeader( &capture->frame,
              cvSize( capture->captureWindow.width,
                  capture->captureWindow.height ),
              IPL_DEPTH_8U, 3, IPL_ORIGIN_TL, 4 );
       capture->frame.imageData = (char *)cvAlloc(capture->frame.imageSize);
    }

  }

  if (capture->is_v4l2_device == 1)
  {

    if(capture->buffers[capture->bufferIndex].start){
      memcpy((char *)capture->frame.imageData,
         (char *)capture->buffers[capture->bufferIndex].start,
         capture->frame.imageSize);
    }

  } else
#endif /* HAVE_CAMV4L2 */
  {

    switch(capture->imageProperties.palette) {
      case VIDEO_PALETTE_RGB24:
        memcpy((char *)capture->frame.imageData,
           (char *)(capture->memoryMap + capture->memoryBuffer.offsets[capture->bufferIndex]),
           capture->frame.imageSize);
        break;
      default:
        fprintf( stderr,
                 ""HIGHGUI ERROR: V4L: Cannot convert from palette %d to RGB\\n"",
                 capture->imageProperties.palette);
        return 0;
    }

  }

   return(&capture->frame);
}

/* TODO: review this adaptation */
static double icvGetPropertyCAM_V4L (CvCaptureCAM_V4L* capture,
                                     int property_id ) {
  char name[32];
  int is_v4l2_device = 0;
      /* initialize the control structure */
  switch (property_id) {
    case CV_CAP_PROP_FRAME_WIDTH:
    case CV_CAP_PROP_FRAME_HEIGHT:
      CLEAR (capture->form);
      capture->form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (-1 == xioctl (capture->deviceHandle, VIDIOC_G_FMT, &capture->form)) {
          /* display an error message, and return an error code */
          perror (""VIDIOC_G_FMT"");
        if (v4l1_ioctl (capture->deviceHandle, VIDIOCGWIN, &capture->captureWindow) < 0) {
          fprintf (stderr, ""HIGHGUI ERROR: V4L: Unable to determine size of incoming image\\n"");
          icvCloseCAM_V4L(capture);
          return -1;
        } else {
          int retval = (property_id == CV_CAP_PROP_FRAME_WIDTH)?capture->captureWindow.width:capture->captureWindow.height;
          return retval / 0xFFFF;
        }
      }
      return (property_id == CV_CAP_PROP_FRAME_WIDTH)?capture->form.fmt.pix.width:capture->form.fmt.pix.height;
    case CV_CAP_PROP_BRIGHTNESS:
      sprintf(name, ""Brightness"");
      capture->control.id = V4L2_CID_BRIGHTNESS;
      break;
    case CV_CAP_PROP_CONTRAST:
      sprintf(name, ""Contrast"");
      capture->control.id = V4L2_CID_CONTRAST;
      break;
    case CV_CAP_PROP_SATURATION:
      sprintf(name, ""Saturation"");
      capture->control.id = V4L2_CID_SATURATION;
      break;
    case CV_CAP_PROP_HUE:
      sprintf(name, ""Hue"");
      capture->control.id = V4L2_CID_HUE;
      break;
    case CV_CAP_PROP_GAIN:
      sprintf(name, ""Gain"");
      capture->control.id = V4L2_CID_GAIN;
      break;
    case CV_CAP_PROP_EXPOSURE:
      sprintf(name, ""Exposure"");
      capture->control.id = V4L2_CID_EXPOSURE;
      break;
    default:
      sprintf(name, ""<unknown property string>"");
      capture->control.id = property_id;
  }

  if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &capture->control) == 0) {
    /* all went well */
    is_v4l2_device = 1;
  } else {
    fprintf(stderr, ""HIGHGUI ERROR: V4L2: Unable to get property %s(%u) - %s\\n"", name, capture->control.id, strerror(errno));
  }

  if (is_v4l2_device == 1) {
      /* get the min/max values */
      int v4l2_min = v4l2_get_ctrl_min(capture, capture->control.id);
      int v4l2_max = v4l2_get_ctrl_max(capture, capture->control.id);

      if ((v4l2_min == -1) && (v4l2_max == -1)) {
        fprintf(stderr, ""HIGHGUI ERROR: V4L2: Property %s(%u) not supported by device\\n"", name, property_id);
        return -1;
      }

      /* all was OK, so convert to 0.0 - 1.0 range, and return the value */
      return ((float)capture->control.value - v4l2_min) / (v4l2_max - v4l2_min);

  } else {
    /* TODO: review this section */
    int retval = -1;

    switch (property_id) {
      case CV_CAP_PROP_BRIGHTNESS:
        retval = capture->imageProperties.brightness;
        break;
      case CV_CAP_PROP_CONTRAST:
        retval = capture->imageProperties.contrast;
        break;
      case CV_CAP_PROP_SATURATION:
        retval = capture->imageProperties.colour;
        break;
      case CV_CAP_PROP_HUE:
        retval = capture->imageProperties.hue;
        break;
      case CV_CAP_PROP_GAIN:
        fprintf(stderr, ""HIGHGUI ERROR: V4L: Gain control in V4L is not supported\\n"");
        return -1;
        break;
      case CV_CAP_PROP_EXPOSURE:
        fprintf(stderr, ""HIGHGUI ERROR: V4L: Exposure control in V4L is not supported\\n"");
        return -1;
        break;
    }

    if (retval == -1) {
      /* there was a problem */
      return -1;
    }
    /* all was OK, so convert to 0.0 - 1.0 range, and return the value */
    return float (retval) / 0xFFFF;
  }
}

static int icvSetVideoSize( CvCaptureCAM_V4L* capture, int w, int h) {

  if (capture->is_v4l2_device == 1)
  {
    char deviceName[MAX_DEVICE_DRIVER_NAME];
    sprintf(deviceName, ""%s"", capture->deviceName);
    icvCloseCAM_V4L(capture);
    _capture_V4L2(capture, deviceName);

    CLEAR (capture->crop);
    capture->crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    capture->crop.c.left       = 0;
    capture->crop.c.top        = 0;
    capture->crop.c.height     = h*24;
    capture->crop.c.width      = w*24;

    /* set the crop area, but don't exit if the device don't support croping */
    xioctl (capture->deviceHandle, VIDIOC_S_CROP, &capture->crop);

    CLEAR (capture->form);
    capture->form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    /* read the current setting, mainly to retreive the pixelformat information */
    xioctl (capture->deviceHandle, VIDIOC_G_FMT, &capture->form);

    /* set the values we want to change */
    capture->form.fmt.pix.width = w;
    capture->form.fmt.pix.height = h;
    capture->form.fmt.win.chromakey = 0;
    capture->form.fmt.win.field = V4L2_FIELD_ANY;
    capture->form.fmt.win.clips = 0;
    capture->form.fmt.win.clipcount = 0;
    capture->form.fmt.pix.field = V4L2_FIELD_ANY;

    /* ask the device to change the size
     * don't test if the set of the size is ok, because some device
     * don't allow changing the size, and we will get the real size
     * later */
    xioctl (capture->deviceHandle, VIDIOC_S_FMT, &capture->form);

    /* try to set framerate to 30 fps */
    struct v4l2_streamparm setfps;
    memset (&setfps, 0, sizeof(struct v4l2_streamparm));
    setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    setfps.parm.capture.timeperframe.numerator = 1;
    setfps.parm.capture.timeperframe.denominator = 30;
    xioctl (capture->deviceHandle, VIDIOC_S_PARM, &setfps);

    /* we need to re-initialize some things, like buffers, because the size has
     * changed */
    capture->FirstCapture = 1;

    /* Get window info again, to get the real value */
    if (-1 == xioctl (capture->deviceHandle, VIDIOC_G_FMT, &capture->form))
    {
      fprintf(stderr, ""HIGHGUI ERROR: V4L/V4L2: Could not obtain specifics of capture window.\\n\\n"");

      icvCloseCAM_V4L(capture);

      return 0;
    }

    return 0;

  } else
  {

    if (capture==0) return 0;
     if (w>capture->capability.maxwidth) {
       w=capture->capability.maxwidth;
     }
     if (h>capture->capability.maxheight) {
       h=capture->capability.maxheight;
     }

     capture->captureWindow.width=w;
     capture->captureWindow.height=h;

     if (ioctl(capture->deviceHandle, VIDIOCSWIN, &capture->captureWindow) < 0) {
       icvCloseCAM_V4L(capture);
       return 0;
     }

     if (ioctl(capture->deviceHandle, VIDIOCGWIN, &capture->captureWindow) < 0) {
       icvCloseCAM_V4L(capture);
       return 0;
     }

     capture->FirstCapture = 1;

  }

  return 0;

}

static int icvSetControl (CvCaptureCAM_V4L* capture, int property_id, double value) {
  struct v4l2_control c;
  __s32 ctrl_value;
  char name[32];
  int is_v4l2  = 1;
  int v4l2_min = 0;
  int v4l2_max = 255;
  if (capture->v4l2_ctrl_ranges == NULL) {
    v4l2_scan_controls(capture);
  }

  CLEAR (capture->control);
  CLEAR (capture->queryctrl);

  /* get current values */
  switch (property_id) {
    case CV_CAP_PROP_BRIGHTNESS:
      sprintf(name, ""Brightness"");
      capture->control.id = V4L2_CID_BRIGHTNESS;
      break;
    case CV_CAP_PROP_CONTRAST:
      sprintf(name, ""Contrast"");
      capture->control.id = V4L2_CID_CONTRAST;
      break;
    case CV_CAP_PROP_SATURATION:
      sprintf(name, ""Saturation"");
      capture->control.id = V4L2_CID_SATURATION;
      break;
    case CV_CAP_PROP_HUE:
      sprintf(name, ""Hue"");
      capture->control.id = V4L2_CID_HUE;
      break;
    case CV_CAP_PROP_GAIN:
      sprintf(name, ""Gain"");
      capture->control.id = V4L2_CID_GAIN;
      break;
    case CV_CAP_PROP_EXPOSURE:
      sprintf(name, ""Exposure"");
      capture->control.id = V4L2_CID_EXPOSURE;
      break;
    default:
      sprintf(name, ""<unknown property string>"");
      capture->control.id = property_id;
  }

  v4l2_min = v4l2_get_ctrl_min(capture, capture->control.id);
  v4l2_max = v4l2_get_ctrl_max(capture, capture->control.id);

  if ((v4l2_min == -1) && (v4l2_max == -1)) {
    fprintf(stderr, ""HIGHGUI ERROR: V4L: Property %s(%u) not supported by device\\n"", name, property_id);
    return -1;
  }

  if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &capture->control) == 0) {
    /* all went well */
  } else {
    fprintf(stderr, ""HIGHGUI ERROR: V4L2: Unable to get property %s(%u) - %s\\n"", name, capture->control.id, strerror(errno));
  }

  if (v4l2_max != 0) {
    double val = value;
    if (value < 0.0) {
      val = 0.0;
    } else if (value > 1.0) {
      val = 1.0;
    }
    ctrl_value = val * (double)(v4l2_max - v4l2_min) + v4l2_min;
  } else {
    ctrl_value = v4l2_get_ctrl_default(capture, capture->control.id) * (double)(v4l2_max - v4l2_min) + v4l2_min;
  }

  /* try and set value as if it was a v4l2 device */
  c.id    = capture->control.id;
  c.value = ctrl_value;
  if (v4l2_ioctl(capture->deviceHandle, VIDIOC_S_CTRL, &c) != 0) {
    /* The driver may clamp the value or return ERANGE, ignored here */
    if (errno != ERANGE) {
      fprintf(stderr, ""HIGHGUI ERROR: V4L2: Failed to set control \\""%d\\"": %s (value %d)\\n"", c.id, strerror(errno), c.value);
      is_v4l2 = 0;
    } else {
      return 0;
    }
  } else {
    return 0;
  }

  if (is_v4l2 == 0) { /* use v4l1_ioctl */
    fprintf(stderr, ""HIGHGUI WARNING: Setting property %u through v4l2 failed. Trying with v4l1.\\n"", c.id);
    int v4l_value;
    /* scale the value to the wanted integer one */
    v4l_value = (int)(0xFFFF * value);

    switch (property_id) {
      case CV_CAP_PROP_BRIGHTNESS:
        capture->imageProperties.brightness = v4l_value;
        break;
      case CV_CAP_PROP_CONTRAST:
        capture->imageProperties.contrast = v4l_value;
        break;
      case CV_CAP_PROP_SATURATION:
        capture->imageProperties.colour = v4l_value;
        break;
      case CV_CAP_PROP_HUE:
        capture->imageProperties.hue = v4l_value;
        break;
      case CV_CAP_PROP_GAIN:
          fprintf(stderr, ""HIGHGUI ERROR: V4L: Gain control in V4L is not supported\\n"");
        return -1;
    case CV_CAP_PROP_EXPOSURE:
        fprintf(stderr, ""HIGHGUI ERROR: V4L: Exposure control in V4L is not supported\\n"");
        return -1;
    default:
        fprintf(stderr, ""HIGHGUI ERROR: V4L: property #%d is not supported\\n"", property_id);
        return -1;
    }

    if (v4l1_ioctl(capture->deviceHandle, VIDIOCSPICT, &capture->imageProperties) < 0){
      fprintf(stderr, ""HIGHGUI ERROR: V4L: Unable to set video informations\\n"");
      icvCloseCAM_V4L(capture);
      return -1;
    }
  }

  /* all was OK */
  return 0;
}

static int icvSetPropertyCAM_V4L(CvCaptureCAM_V4L* capture, int property_id, double value){
    static int width = 0, height = 0;
    int retval;

    /* initialization */
    retval = 0;

    /* two subsequent calls setting WIDTH and HEIGHT will change
       the video size */
    /* the first one will return an error, though. */

    switch (property_id) {
    case CV_CAP_PROP_FRAME_WIDTH:
        width = cvRound(value);
        capture->width = width;
        if(width !=0 && height != 0) {
            retval = icvSetVideoSize( capture, width, height);
            width = height = 0;
        }
        break;
    case CV_CAP_PROP_FRAME_HEIGHT:
        height = cvRound(value);
        capture->height = height;
        if(width !=0 && height != 0) {
            retval = icvSetVideoSize( capture, width, height);
            width = height = 0;
        }
        break;
    case CV_CAP_PROP_FPS:
        struct v4l2_streamparm setfps;
        memset (&setfps, 0, sizeof(struct v4l2_streamparm));
        setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        setfps.parm.capture.timeperframe.numerator = 1;
        setfps.parm.capture.timeperframe.denominator = value;
        if (xioctl (capture->deviceHandle, VIDIOC_S_PARM, &setfps) < 0){
            fprintf(stderr, ""HIGHGUI ERROR: V4L: Unable to set camera FPS\\n"");
            retval=0;
        }
        break;
    default:
        retval = icvSetControl(capture, property_id, value);
    }

    /* return the the status */
    return retval;
}

static void icvCloseCAM_V4L( CvCaptureCAM_V4L* capture ){
   /* Deallocate space - Hopefully, no leaks */
   if (capture) {
     v4l2_free_ranges(capture);
     if (capture->is_v4l2_device == 0) {
       if (capture->mmaps) {
         free(capture->mmaps);
       }
       if (capture->memoryMap) {
         v4l1_munmap(capture->memoryMap, capture->memoryBuffer.size);
       }
       if (capture->deviceHandle != -1) {
         v4l1_close(capture->deviceHandle);
       }
     } else {
       capture->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
       if (xioctl(capture->deviceHandle, VIDIOC_STREAMOFF, &capture->type) < 0) {
         perror (""Unable to stop the stream."");
       }
       for (unsigned int n_buffers2 = 0; n_buffers2 < capture->req.count; ++n_buffers2) {
         if (-1 == v4l2_munmap (capture->buffers[n_buffers2].start, capture->buffers[n_buffers2].length)) {
           perror (""munmap"");
         }
       }

       if (capture->deviceHandle != -1) {
         v4l2_close(capture->deviceHandle);
       }
     }

     if (capture->frame.imageData)
       cvFree(&capture->frame.imageData);

#ifdef USE_TEMP_BUFFER
     if (capture->buffers[MAX_V4L_BUFFERS].start) {
       free(capture->buffers[MAX_V4L_BUFFERS].start);
       capture->buffers[MAX_V4L_BUFFERS].start = NULL;
     }
#endif

     free(capture->deviceName);
     capture->deviceName = NULL;
     //v4l2_free_ranges(capture);
     //cvFree((void **)capture);
   }
};


class CvCaptureCAM_V4L_CPP : CvCapture
{
public:
    CvCaptureCAM_V4L_CPP() { captureV4L = 0; }
    virtual ~CvCaptureCAM_V4L_CPP() { close(); }

    virtual bool open( int index );
    virtual void close();

    virtual double getProperty(int);
    virtual bool setProperty(int, double);
    virtual bool grabFrame();
    virtual IplImage* retrieveFrame(int);
protected:

    CvCaptureCAM_V4L* captureV4L;
};

bool CvCaptureCAM_V4L_CPP::open( int index )
{
    close();
    captureV4L = icvCaptureFromCAM_V4L(index);
    return captureV4L != 0;
}

void CvCaptureCAM_V4L_CPP::close()
{
    if( captureV4L )
    {
        icvCloseCAM_V4L( captureV4L );
        cvFree( &captureV4L );
    }
}

bool CvCaptureCAM_V4L_CPP::grabFrame()
{
    return captureV4L ? icvGrabFrameCAM_V4L( captureV4L ) != 0 : false;
}

IplImage* CvCaptureCAM_V4L_CPP::retrieveFrame(int)
{
    return captureV4L ? icvRetrieveFrameCAM_V4L( captureV4L, 0 ) : 0;
}

double CvCaptureCAM_V4L_CPP::getProperty( int propId )
{
    return captureV4L ? icvGetPropertyCAM_V4L( captureV4L, propId ) : 0.0;
}

bool CvCaptureCAM_V4L_CPP::setProperty( int propId, double value )
{
    return captureV4L ? icvSetPropertyCAM_V4L( captureV4L, propId, value ) != 0 : false;
}

CvCapture* cvCreateCameraCapture_V4L( int index )
{
    CvCaptureCAM_V4L_CPP* capture = new CvCaptureCAM_V4L_CPP;

    if( capture->open( index ))
        return (CvCapture*)capture;

    delete capture;
    return 0;
}

#endif
",16158,True,2926.132456859077,median
"// Copyright (c) YugaByte, Inc.
//
// 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 ""yb/cdc/cdc_service.h""

#include <shared_mutex>
#include <chrono>
#include <memory>

#include <boost/algorithm/string.hpp>

#include ""yb/cdc/cdc_producer.h""
#include ""yb/cdc/cdc_service.proxy.h""
#include ""yb/cdc/cdc_rpc.h""

#include ""yb/client/client.h""

#include ""yb/common/entity_ids.h""
#include ""yb/common/ql_expr.h""
#include ""yb/common/ql_value.h""
#include ""yb/common/pg_system_attr.h""
#include ""yb/common/schema.h""
#include ""yb/common/wire_protocol.h""

#include ""yb/consensus/log.h""
#include ""yb/consensus/raft_consensus.h""
#include ""yb/consensus/replicate_msgs_holder.h""

#include ""yb/client/meta_cache.h""
#include ""yb/client/schema.h""
#include ""yb/client/session.h""
#include ""yb/client/table.h""
#include ""yb/client/table_alterer.h""
#include ""yb/client/table_handle.h""
#include ""yb/client/yb_op.h""
#include ""yb/client/yb_table_name.h""

#include ""yb/gutil/dynamic_annotations.h""
#include ""yb/gutil/strings/join.h""
#include ""yb/master/master_client.pb.h""
#include ""yb/master/master_defaults.h""
#include ""yb/rpc/rpc_context.h""
#include ""yb/rpc/rpc_controller.h""

#include ""yb/tablet/tablet.h""
#include ""yb/tablet/tablet_metadata.h""
#include ""yb/tablet/tablet_peer.h""
#include ""yb/tablet/transaction_participant.h""

#include ""yb/tserver/tablet_server.h""
#include ""yb/tserver/ts_tablet_manager.h""
#include ""yb/tserver/service_util.h""
#include ""yb/util/debug/trace_event.h""
#include ""yb/util/flag_tags.h""
#include ""yb/util/format.h""
#include ""yb/util/logging.h""
#include ""yb/util/metrics.h""
#include ""yb/util/monotime.h""
#include ""yb/util/scope_exit.h""
#include ""yb/util/shared_lock.h""
#include ""yb/util/status_format.h""
#include ""yb/util/status_log.h""
#include ""yb/util/trace.h""
#include ""yb/yql/cql/ql/util/statement_result.h""

constexpr uint32_t kUpdateIntervalMs = 15 * 1000;

DEFINE_int32(cdc_read_rpc_timeout_ms, 30 * 1000,
             ""Timeout used for CDC read rpc calls.  Reads normally occur cross-cluster."");
TAG_FLAG(cdc_read_rpc_timeout_ms, advanced);

DEFINE_int32(cdc_write_rpc_timeout_ms, 30 * 1000,
             ""Timeout used for CDC write rpc calls.  Writes normally occur intra-cluster."");
TAG_FLAG(cdc_write_rpc_timeout_ms, advanced);

DEFINE_int32(cdc_ybclient_reactor_threads, 50,
             ""The number of reactor threads to be used for processing ybclient ""
             ""requests for CDC."");
TAG_FLAG(cdc_ybclient_reactor_threads, advanced);

DEFINE_int32(cdc_state_checkpoint_update_interval_ms, kUpdateIntervalMs,
             ""Rate at which CDC state's checkpoint is updated."");

DEFINE_string(certs_for_cdc_dir, """",
              ""The parent directory of where all certificates for xCluster producer universes will ""
              ""be stored, for when the producer and consumer clusters use different certificates. ""
              ""Place the certificates for each producer cluster in ""
              ""<certs_for_cdc_dir>/<producer_cluster_id>/*."");

DEFINE_int32(update_min_cdc_indices_interval_secs, 60,
             ""How often to read cdc_state table to get the minimum applied index for each tablet ""
             ""across all streams. This information is used to correctly keep log files that ""
             ""contain unapplied entries. This is also the rate at which a tablet's minimum ""
             ""replicated index across all streams is sent to the other peers in the configuration. ""
             ""If flag enable_log_retention_by_op_idx is disabled, this flag has no effect."");

DEFINE_int32(update_metrics_interval_ms, kUpdateIntervalMs,
             ""How often to update xDC cluster metrics."");

DEFINE_bool(enable_cdc_state_table_caching, true, ""Enable caching the cdc_state table schema."");

DEFINE_bool(enable_collect_cdc_metrics, true, ""Enable collecting cdc metrics."");

DEFINE_double(cdc_read_safe_deadline_ratio, .10,
              ""When the heartbeat deadline has this percentage of time remaining, ""
              ""the master should halt tablet report processing so it can respond in time."");

DECLARE_bool(enable_log_retention_by_op_idx);

DECLARE_int32(cdc_checkpoint_opid_interval_ms);

METRIC_DEFINE_entity(cdc);

namespace yb {
namespace cdc {

using namespace std::literals;

using rpc::RpcContext;
using tserver::TSTabletManager;
using client::internal::RemoteTabletServer;

constexpr int kMaxDurationForTabletLookup = 50;
const client::YBTableName kCdcStateTableName(
    YQL_DATABASE_CQL, master::kSystemNamespaceName, master::kCdcStateTableName);

CDCServiceImpl::CDCServiceImpl(TSTabletManager* tablet_manager,
                               const scoped_refptr<MetricEntity>& metric_entity_server,
                               MetricRegistry* metric_registry)
    : CDCServiceIf(metric_entity_server),
      tablet_manager_(tablet_manager),
      metric_registry_(metric_registry),
      server_metrics_(std::make_shared<CDCServerMetrics>(metric_entity_server)) {
  const auto server = tablet_manager->server();
  async_client_init_.emplace(
      ""cdc_client"", FLAGS_cdc_ybclient_reactor_threads, FLAGS_cdc_read_rpc_timeout_ms / 1000,
      server->permanent_uuid(), &server->options(), server->metric_entity(), server->mem_tracker(),
      server->messenger());
  async_client_init_->Start();

  update_peers_and_metrics_thread_.reset(new std::thread(
      &CDCServiceImpl::UpdatePeersAndMetrics, this));
}

CDCServiceImpl::~CDCServiceImpl() {
  Shutdown();
}

namespace {

bool YsqlTableHasPrimaryKey(const client::YBSchema& schema) {
  for (const auto& col : schema.columns()) {
      if (col.order() == static_cast<int32_t>(PgSystemAttrNum::kYBRowId)) {
        // ybrowid column is added for tables that don't have user-specified primary key.
        return false;
    }
  }
  return true;
}

bool IsTabletPeerLeader(const std::shared_ptr<tablet::TabletPeer>& peer) {
  return peer->LeaderStatus() == consensus::LeaderStatus::LEADER_AND_READY;
}
} // namespace

template <class ReqType, class RespType>
bool CDCServiceImpl::CheckOnline(const ReqType* req, RespType* resp, rpc::RpcContext* rpc) {
  TRACE(""Received RPC $0: $1"", rpc->ToString(), req->DebugString());
  if (PREDICT_FALSE(!tablet_manager_)) {
    SetupErrorAndRespond(resp->mutable_error(),
                         STATUS(ServiceUnavailable, ""Tablet Server is not running""),
                         CDCErrorPB::NOT_RUNNING,
                         rpc);
    return false;
  }
  return true;
}

void CDCServiceImpl::CreateCDCStream(const CreateCDCStreamRequestPB* req,
                                     CreateCDCStreamResponsePB* resp,
                                     RpcContext context) {
  if (!CheckOnline(req, resp, &context)) {
    return;
  }

  RPC_CHECK_AND_RETURN_ERROR(req->has_table_id(),
                             STATUS(InvalidArgument, ""Table ID is required to create CDC stream""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  std::shared_ptr<client::YBTable> table;
  Status s = async_client_init_->client()->OpenTable(req->table_id(), &table);
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::TABLE_NOT_FOUND, context);

  // We don't allow CDC on YEDIS and tables without a primary key.
  if (req->record_format() != CDCRecordFormat::WAL) {
    RPC_CHECK_NE_AND_RETURN_ERROR(table->table_type(), client::YBTableType::REDIS_TABLE_TYPE,
                                  STATUS(InvalidArgument, ""Cannot setup CDC on YEDIS_TABLE""),
                                  resp->mutable_error(),
                                  CDCErrorPB::INVALID_REQUEST,
                                  context);

    // Check if YSQL table has a primary key. CQL tables always have a user specified primary key.
    RPC_CHECK_AND_RETURN_ERROR(
        table->table_type() != client::YBTableType::PGSQL_TABLE_TYPE ||
        YsqlTableHasPrimaryKey(table->schema()),
        STATUS(InvalidArgument, ""Cannot setup CDC on table without primary key""),
        resp->mutable_error(),
        CDCErrorPB::INVALID_REQUEST,
        context);
  }

  std::unordered_map<std::string, std::string> options;
  options.reserve(2);
  options.emplace(kRecordType, CDCRecordType_Name(req->record_type()));
  options.emplace(kRecordFormat, CDCRecordFormat_Name(req->record_format()));

  auto result = async_client_init_->client()->CreateCDCStream(req->table_id(), options);
  RPC_CHECK_AND_RETURN_ERROR(result.ok(), result.status(), resp->mutable_error(),
                             CDCErrorPB::INTERNAL_ERROR, context);

  resp->set_stream_id(*result);

  // Add stream to cache.
  AddStreamMetadataToCache(*result, std::make_shared<StreamMetadata>(req->table_id(),
                                                                     req->record_type(),
                                                                     req->record_format()));
  context.RespondSuccess();
}

void CDCServiceImpl::DeleteCDCStream(const DeleteCDCStreamRequestPB* req,
                                     DeleteCDCStreamResponsePB* resp,
                                     RpcContext context) {
  if (!CheckOnline(req, resp, &context)) {
    return;
  }

  LOG(INFO) << ""Received DeleteCDCStream request "" << req->ShortDebugString();

  RPC_CHECK_AND_RETURN_ERROR(req->stream_id_size() > 0,
                             STATUS(InvalidArgument, ""Stream ID is required to delete CDC stream""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  vector<CDCStreamId> streams(req->stream_id().begin(), req->stream_id().end());
  Status s = async_client_init_->client()->DeleteCDCStream(
        streams,
        (req->has_force_delete() && req->force_delete()),
        (req->has_ignore_errors() && req->ignore_errors()));
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, context);

  context.RespondSuccess();
}

void CDCServiceImpl::ListTablets(const ListTabletsRequestPB* req,
                                 ListTabletsResponsePB* resp,
                                 RpcContext context) {
  if (!CheckOnline(req, resp, &context)) {
    return;
  }

  RPC_CHECK_AND_RETURN_ERROR(req->has_stream_id(),
                             STATUS(InvalidArgument, ""Stream ID is required to list tablets""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  auto tablets = GetTablets(req->stream_id());
  RPC_CHECK_AND_RETURN_ERROR(tablets.ok(), tablets.status(), resp->mutable_error(),
                             CDCErrorPB::INTERNAL_ERROR, context);

  if (!req->local_only()) {
    resp->mutable_tablets()->Reserve(tablets->size());
  }

  for (const auto& tablet : *tablets) {
    // Filter local tablets if needed.
    if (req->local_only()) {
      bool is_local = false;
      for (const auto& replica : tablet.replicas()) {
        if (replica.ts_info().permanent_uuid() == tablet_manager_->server()->permanent_uuid()) {
          is_local = true;
          break;
        }
      }

      if (!is_local) {
        continue;
      }
    }

    auto res = resp->add_tablets();
    res->set_tablet_id(tablet.tablet_id());
    res->mutable_tservers()->Reserve(tablet.replicas_size());
    for (const auto& replica : tablet.replicas()) {
      auto tserver =  res->add_tservers();
      tserver->mutable_broadcast_addresses()->CopyFrom(replica.ts_info().broadcast_addresses());
      if (tserver->broadcast_addresses_size() == 0) {
        LOG(WARNING) << ""No public broadcast addresses found for ""
                     << replica.ts_info().permanent_uuid() << "".  Using private addresses instead."";
        tserver->mutable_broadcast_addresses()->CopyFrom(replica.ts_info().private_rpc_addresses());
      }
    }
  }

  context.RespondSuccess();
}

Result<google::protobuf::RepeatedPtrField<master::TabletLocationsPB>> CDCServiceImpl::GetTablets(
    const CDCStreamId& stream_id) {
  auto stream_metadata = VERIFY_RESULT(GetStream(stream_id));
  client::YBTableName table_name;
  table_name.set_table_id(stream_metadata->table_id);
  google::protobuf::RepeatedPtrField<master::TabletLocationsPB> tablets;
  RETURN_NOT_OK(async_client_init_->client()->GetTablets(
      table_name, 0,
      &tablets, /* partition_list_version =*/ nullptr,
      RequireTabletsRunning::kFalse, master::IncludeInactive::kTrue));
  return tablets;
}

void CDCServiceImpl::GetChanges(const GetChangesRequestPB* req,
                                GetChangesResponsePB* resp,
                                RpcContext context) {
  if (!CheckOnline(req, resp, &context)) {
    return;
  }
  YB_LOG_EVERY_N_SECS(INFO, 300) << ""Received GetChanges request "" << req->ShortDebugString();

  RPC_CHECK_AND_RETURN_ERROR(req->has_tablet_id(),
                             STATUS(InvalidArgument, ""Tablet ID is required to get CDC changes""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);
  RPC_CHECK_AND_RETURN_ERROR(req->has_stream_id(),
                             STATUS(InvalidArgument, ""Stream ID is required to get CDC changes""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  // Check that requested tablet_id is part of the CDC stream.
  ProducerTabletInfo producer_tablet = {"""" /* UUID */, req->stream_id(), req->tablet_id()};
  Status s = CheckTabletValidForStream(producer_tablet);
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::INVALID_REQUEST, context);

  std::shared_ptr<tablet::TabletPeer> tablet_peer;
  s = tablet_manager_->GetTabletPeer(req->tablet_id(), &tablet_peer);
  auto original_leader_term = tablet_peer ? tablet_peer->LeaderTerm() : OpId::kUnknownTerm;

  // If we we can't serve this tablet...
  if (s.IsNotFound() || tablet_peer->LeaderStatus() != consensus::LeaderStatus::LEADER_AND_READY) {
    if (req->serve_as_proxy()) {
      // Forward GetChanges() to tablet leader. This commonly happens in Kubernetes setups.
      auto context_ptr = std::make_shared<RpcContext>(std::move(context));
      TabletLeaderGetChanges(req, resp, context_ptr, tablet_peer);
    // Otherwise, figure out the proper return code.
    } else if (s.IsNotFound()) {
      SetupErrorAndRespond(resp->mutable_error(), s, CDCErrorPB::TABLET_NOT_FOUND, &context);
    } else if (tablet_peer->LeaderStatus() == consensus::LeaderStatus::NOT_LEADER) {
      // TODO: we may be able to get some changes, even if we're not the leader.
      SetupErrorAndRespond(resp->mutable_error(),
          STATUS(NotFound, Format(""Not leader for $0"", req->tablet_id())),
          CDCErrorPB::TABLET_NOT_FOUND, &context);
    } else {
      SetupErrorAndRespond(resp->mutable_error(),
          STATUS(LeaderNotReadyToServe, ""Not ready to serve""),
          CDCErrorPB::LEADER_NOT_READY, &context);
    }
    return;
  }

  // This is the leader tablet, so mark cdc as enabled.
  cdc_enabled_.store(true, std::memory_order_release);

  auto session = async_client_init_->client()->NewSession();
  CoarseTimePoint deadline = context.GetClientDeadline();
  if (deadline == CoarseTimePoint::max()) { // Not specified by user.
    deadline = CoarseMonoClock::now() + async_client_init_->client()->default_rpc_timeout();
  }
  session->SetDeadline(deadline);
  OpId op_id;

  if (req->has_from_checkpoint()) {
    op_id = OpId::FromPB(req->from_checkpoint().op_id());
  } else {
    auto result = GetLastCheckpoint(producer_tablet, session);
    RPC_CHECK_AND_RETURN_ERROR(result.ok(), result.status(), resp->mutable_error(),
                               CDCErrorPB::INTERNAL_ERROR, context);
    op_id = *result;
  }

  auto record = GetStream(req->stream_id());
  RPC_CHECK_AND_RETURN_ERROR(record.ok(), record.status(), resp->mutable_error(),
                             CDCErrorPB::INTERNAL_ERROR, context);

  int64_t last_readable_index;
  consensus::ReplicateMsgsHolder msgs_holder;
  MemTrackerPtr mem_tracker = GetMemTracker(tablet_peer, producer_tablet);

  // Calculate deadline to be passed to GetChanges.
  CoarseTimePoint get_changes_deadline = CoarseTimePoint::max();
  if (deadline != CoarseTimePoint::max()) {
    // Check if we are too close to calculate a safe deadline.
    RPC_CHECK_AND_RETURN_ERROR(
      deadline - CoarseMonoClock::Now() > 1ms,
      STATUS(TimedOut, ""Too close to rpc timeout to call GetChanges.""),
      resp->mutable_error(),
      CDCErrorPB::INTERNAL_ERROR, context);

    // Calculate a safe deadline so that CdcProducer::GetChanges times out
    // 20% faster than CdcServiceImpl::GetChanges. This gives enough
    // time (unless timeouts are unrealistically small) for CdcServiceImpl::GetChanges
    // to finish post-processing and return the partial results without itself timing out.
    const auto safe_deadline = deadline -
      (FLAGS_cdc_read_rpc_timeout_ms * 1ms * FLAGS_cdc_read_safe_deadline_ratio);
    get_changes_deadline = ToCoarse(MonoTime::FromUint64(safe_deadline.time_since_epoch().count()));
  }

  // Read the latest changes from the Log.
  s = cdc::GetChanges(
      req->stream_id(), req->tablet_id(), op_id, *record->get(), tablet_peer, mem_tracker,
      &msgs_holder, resp, &last_readable_index, get_changes_deadline);
  RPC_STATUS_RETURN_ERROR(
      s,
      resp->mutable_error(),
      s.IsNotFound() ? CDCErrorPB::CHECKPOINT_TOO_OLD : CDCErrorPB::UNKNOWN_ERROR,
      context);

  // Verify leadership was maintained for the duration of the GetChanges() read.
  s = tablet_manager_->GetTabletPeer(req->tablet_id(), &tablet_peer);
  if (s.IsNotFound() || tablet_peer->LeaderStatus() != consensus::LeaderStatus::LEADER_AND_READY ||
      tablet_peer->LeaderTerm() != original_leader_term) {
    SetupErrorAndRespond(resp->mutable_error(),
        STATUS(NotFound, Format(""Not leader for $0"", req->tablet_id())),
        CDCErrorPB::TABLET_NOT_FOUND, &context);
    return;
  }

  // Store information about the last server read & remote client ACK.
  uint64_t last_record_hybrid_time = resp->records_size() > 0 ?
      resp->records(resp->records_size() - 1).time() : 0;

  s = UpdateCheckpoint(producer_tablet, OpId::FromPB(resp->checkpoint().op_id()), op_id, session,
                       last_record_hybrid_time);
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, context);

  {
    std::shared_ptr<consensus::Consensus> shared_consensus = tablet_peer->shared_consensus();

    RPC_CHECK_NE_AND_RETURN_ERROR(shared_consensus, nullptr,
        STATUS_SUBSTITUTE(InternalError, ""Failed to get tablet $0 peer consensus"",
            req->tablet_id()),
        resp->mutable_error(),
        CDCErrorPB::INTERNAL_ERROR, context);

    shared_consensus->UpdateCDCConsumerOpId(GetMinSentCheckpointForTablet(req->tablet_id()));
  }

  // Update relevant GetChanges metrics before handing off the Response.
  auto tablet_metric = GetCDCTabletMetrics(producer_tablet, tablet_peer);
  if (tablet_metric) {
    auto lid = resp->checkpoint().op_id();
    tablet_metric->last_read_opid_term->set_value(lid.term());
    tablet_metric->last_read_opid_index->set_value(lid.index());
    tablet_metric->last_readable_opid_index->set_value(last_readable_index);
    tablet_metric->last_checkpoint_opid_index->set_value(op_id.index);
    if (resp->records_size() > 0) {
      auto& last_record = resp->records(resp->records_size()-1);
      tablet_metric->last_read_hybridtime->set_value(last_record.time());
      auto last_record_micros = HybridTime(last_record.time()).GetPhysicalValueMicros();
      tablet_metric->last_read_physicaltime->set_value(last_record_micros);
      // Only count bytes responded if we are including a response payload.
      tablet_metric->rpc_payload_bytes_responded->Increment(resp->ByteSize());
      // Get the physical time of the last committed record on producer.
      auto last_replicated_micros = GetLastReplicatedTime(tablet_peer);
      tablet_metric->async_replication_sent_lag_micros->set_value(
          last_replicated_micros - last_record_micros);
      auto& first_record = resp->records(0);
      auto first_record_micros = HybridTime(first_record.time()).GetPhysicalValueMicros();
      tablet_metric->last_checkpoint_physicaltime->set_value(first_record_micros);
      tablet_metric->async_replication_committed_lag_micros->set_value(
          last_replicated_micros - first_record_micros);
    } else {
      tablet_metric->rpc_heartbeats_responded->Increment();
      // If there are no more entries to be read, that means we're caught up.
      auto last_replicated_micros = GetLastReplicatedTime(tablet_peer);
      tablet_metric->last_read_physicaltime->set_value(last_replicated_micros);
      tablet_metric->last_checkpoint_physicaltime->set_value(last_replicated_micros);
      tablet_metric->async_replication_sent_lag_micros->set_value(0);
      tablet_metric->async_replication_committed_lag_micros->set_value(0);
    }
  }

  context.RespondSuccess();
}

Status CDCServiceImpl::UpdatePeersCdcMinReplicatedIndex(const TabletId& tablet_id,
                                                        int64_t min_index) {
  std::vector<client::internal::RemoteTabletServer *> servers;
  RETURN_NOT_OK(GetTServers(tablet_id, &servers));
  for (const auto &server : servers) {
    if (server->IsLocal()) {
      // We modify our log directly. Avoid calling itself through the proxy.
      continue;
    }
    LOG(INFO) << ""Modifying remote peer "" << server->ToString();
    auto proxy = GetCDCServiceProxy(server);
    UpdateCdcReplicatedIndexRequestPB update_index_req;
    UpdateCdcReplicatedIndexResponsePB update_index_resp;
    update_index_req.set_tablet_id(tablet_id);
    update_index_req.set_replicated_index(min_index);
    rpc::RpcController rpc;
    rpc.set_timeout(MonoDelta::FromMilliseconds(FLAGS_cdc_write_rpc_timeout_ms));
    RETURN_NOT_OK(proxy->UpdateCdcReplicatedIndex(update_index_req, &update_index_resp, &rpc));
    if (update_index_resp.has_error()) {
      return StatusFromPB(update_index_resp.error().status());
    }
  }
  return Status::OK();
}

void CDCServiceImpl::ComputeLagMetric(int64_t last_replicated_micros,
                                      int64_t metric_last_timestamp_micros,
                                      int64_t cdc_state_last_replication_time_micros,
                                      scoped_refptr<AtomicGauge<int64_t>> metric) {
  if (metric_last_timestamp_micros == 0) {
    // The tablet metric timestamp is uninitialized, so try to use last replicated time in cdc
    // state.
    if (cdc_state_last_replication_time_micros == 0) {
      // Last replicated time in cdc state is unitialized as well, so set the metric value to
      // 0 and update later when we have a suitable lower bound.
      metric->set_value(0);
    } else {
      metric->set_value(last_replicated_micros - cdc_state_last_replication_time_micros);
    }
  } else {
    metric->set_value(last_replicated_micros - metric_last_timestamp_micros);
  }
}

void CDCServiceImpl::UpdateLagMetrics() {
  TabletCheckpoints tablet_checkpoints;
  {
    SharedLock<decltype(mutex_)> l(mutex_);
    tablet_checkpoints = tablet_checkpoints_;
  }

  auto cdc_state_table_result = GetCdcStateTable();
  if (!cdc_state_table_result.ok()) {
    // It is possible that this runs before the cdc_state table is created. This is
    // ok. It just means that this is the first time the cluster starts.
    YB_LOG_EVERY_N_SECS(WARNING, 30)
        << ""Unable to open table "" << kCdcStateTableName.table_name() << "" for metrics update."";
    return;
  }

  std::unordered_set<ProducerTabletInfo, ProducerTabletInfo::Hash> tablets_in_cdc_state_table;
  client::TableIteratorOptions options;
  options.columns = std::vector<string>{
      master::kCdcTabletId, master::kCdcStreamId, master::kCdcLastReplicationTime};
  bool failed = false;
  options.error_handler = [&failed](const Status& status) {
    YB_LOG_EVERY_N_SECS(WARNING, 30) << ""Scan of table "" << kCdcStateTableName.table_name()
                                     << "" failed: "" << status << "". Could not update metrics."";
    failed = true;
  };
  // First go through tablets in the cdc_state table and update metrics for each one.
  for (const auto& row : client::TableRange(**cdc_state_table_result, options)) {
    auto tablet_id = row.column(master::kCdcTabletIdIdx).string_value();
    auto stream_id = row.column(master::kCdcStreamIdIdx).string_value();
    std::shared_ptr<tablet::TabletPeer> tablet_peer;
    Status s = tablet_manager_->GetTabletPeer(tablet_id, &tablet_peer);
    if (s.IsNotFound()) {
      continue;
    }

    ProducerTabletInfo tablet_info = {"""" /* universe_uuid */, stream_id, tablet_id};
    tablets_in_cdc_state_table.insert(tablet_info);
    auto tablet_metric = GetCDCTabletMetrics(tablet_info, tablet_peer);
    if (!tablet_metric) {
      continue;
    }
    if (tablet_peer->LeaderStatus() != consensus::LeaderStatus::LEADER_AND_READY) {
      // Set lag to 0 because we're not the leader for this tablet anymore, which means another peer
      // is responsible for tracking this tablet's lag.
      tablet_metric->async_replication_sent_lag_micros->set_value(0);
      tablet_metric->async_replication_committed_lag_micros->set_value(0);
    } else {
      // Get the physical time of the last committed record on producer.
      auto last_replicated_micros = GetLastReplicatedTime(tablet_peer);
      const auto& timestamp_ql_value = row.column(2);
      auto cdc_state_last_replication_time_micros =
          !timestamp_ql_value.IsNull() ?
          timestamp_ql_value.timestamp_value().ToInt64() : 0;
      auto last_sent_micros = tablet_metric->last_read_physicaltime->value();
      ComputeLagMetric(last_replicated_micros, last_sent_micros,
                       cdc_state_last_replication_time_micros,
                       tablet_metric->async_replication_sent_lag_micros);
      auto last_committed_micros = tablet_metric->last_checkpoint_physicaltime->value();
      ComputeLagMetric(last_replicated_micros, last_committed_micros,
                       cdc_state_last_replication_time_micros,
                       tablet_metric->async_replication_committed_lag_micros);
    }
  }
  if (failed) {
    RefreshCdcStateTable();
    return;
  }

  // Now, go through tablets in tablet_checkpoints_ and set lag to 0 for all tablets we're no
  // longer replicating.
  for (auto it = tablet_checkpoints.begin(); it != tablet_checkpoints.end(); it++) {
    ProducerTabletInfo tablet_info = {"""" /* universe_uuid */, it->stream_id(), it->tablet_id()};
    if (tablets_in_cdc_state_table.find(tablet_info) == tablets_in_cdc_state_table.end()) {
      // We're no longer replicating this tablet, so set lag to 0.
      std::shared_ptr<tablet::TabletPeer> tablet_peer;
      Status s = tablet_manager_->GetTabletPeer(it->tablet_id(), &tablet_peer);
      if (s.IsNotFound()) {
        continue;
      }
      auto tablet_metric = GetCDCTabletMetrics(it->producer_tablet_info, tablet_peer);
      if (!tablet_metric) {
        continue;
      }
      tablet_metric->async_replication_sent_lag_micros->set_value(0);
      tablet_metric->async_replication_committed_lag_micros->set_value(0);
    }
  }
}

bool CDCServiceImpl::ShouldUpdateLagMetrics(MonoTime time_since_update_metrics) {
  // Only update metrics if cdc is enabled, which means we have a valid replication stream.
  return GetAtomicFlag(&FLAGS_enable_collect_cdc_metrics) &&
         (time_since_update_metrics == MonoTime::kUninitialized ||
         MonoTime::Now() - time_since_update_metrics >=
             MonoDelta::FromMilliseconds(GetAtomicFlag(&FLAGS_update_metrics_interval_ms)));
}

bool CDCServiceImpl::CDCEnabled() {
  return cdc_enabled_.load(std::memory_order_acquire);
}

Result<std::shared_ptr<yb::client::TableHandle>> CDCServiceImpl::GetCdcStateTable() {
  bool use_cache = GetAtomicFlag(&FLAGS_enable_cdc_state_table_caching);
  {
    SharedLock<decltype(mutex_)> l(mutex_);
    if (cdc_state_table_ && use_cache) {
      return cdc_state_table_;
    }
    if (cdc_service_stopped_) {
      return STATUS(ShutdownInProgress, """");
    }
  }

  auto cdc_state_table = std::make_shared<yb::client::TableHandle>();
  auto s = cdc_state_table->Open(kCdcStateTableName, async_client_init_->client());
  // It is possible that this runs before the cdc_state table is created.
  RETURN_NOT_OK(s);

  {
    std::lock_guard<decltype(mutex_)> l(mutex_);
    if (cdc_state_table_ && use_cache) {
      return cdc_state_table_;
    }
    if (cdc_service_stopped_) {
      return STATUS(ShutdownInProgress, """");
    }
    cdc_state_table_ = cdc_state_table;
    return cdc_state_table_;
  }
}

void CDCServiceImpl::RefreshCdcStateTable() {
  // Set cached value to null so we regenerate it on the next call.
  std::lock_guard<decltype(mutex_)> l(mutex_);
  cdc_state_table_ = nullptr;
}

Status CDCServiceImpl::RefreshCacheOnFail(const Status& s) {
  if (!s.ok()) {
    RefreshCdcStateTable();
  }
  return s;
}

MicrosTime CDCServiceImpl::GetLastReplicatedTime(
    const std::shared_ptr<tablet::TabletPeer>& tablet_peer) {
  yb::tablet::RemoveIntentsData data;
  tablet_peer->GetLastReplicatedData(&data);
  return data.log_ht.GetPhysicalValueMicros();
}

void CDCServiceImpl::UpdatePeersAndMetrics() {
  MonoTime time_since_update_peers = MonoTime::kUninitialized;
  MonoTime time_since_update_metrics = MonoTime::kUninitialized;

  // Returns false if the CDC service has been stopped.
  auto sleep_while_not_stopped = [this]() {
    int min_sleep_ms = std::min(100, GetAtomicFlag(&FLAGS_update_metrics_interval_ms));
    auto sleep_period = MonoDelta::FromMilliseconds(min_sleep_ms);
    SleepFor(sleep_period);

    SharedLock<decltype(mutex_)> l(mutex_);
    return !cdc_service_stopped_;
  };

  do {
    if (!cdc_enabled_.load(std::memory_order_acquire)) {
      // Have not yet received any GetChanges requests, so skip background thread work.
      continue;
    }
    // Should we update lag metrics default every 1s.
    if (ShouldUpdateLagMetrics(time_since_update_metrics)) {
      UpdateLagMetrics();
      time_since_update_metrics = MonoTime::Now();
    }

    // If its not been 60s since the last peer update, continue.
    if (!FLAGS_enable_log_retention_by_op_idx ||
        (time_since_update_peers != MonoTime::kUninitialized &&
         MonoTime::Now() - time_since_update_peers <
             MonoDelta::FromSeconds(GetAtomicFlag(&FLAGS_update_min_cdc_indices_interval_secs)))) {
      continue;
    }

    time_since_update_peers = MonoTime::Now();
    LOG(INFO) << ""Started to read minimum replicated indices for all tablets"";

    auto cdc_state_table_result = GetCdcStateTable();
    if (!cdc_state_table_result.ok()) {
      // It is possible that this runs before the cdc_state table is created. This is
      // ok. It just means that this is the first time the cluster starts.
      YB_LOG_EVERY_N_SECS(WARNING, 3600) << ""Unable to open table ""
                                         << kCdcStateTableName.table_name()
                                         << "". CDC min replicated indices won't be updated"";
      continue;
    }

    int count = 0;
    std::unordered_map<std::string, int64_t> tablet_min_checkpoint_index;
    client::TableIteratorOptions options;
    bool failed = false;
    options.error_handler = [&failed](const Status& status) {
      LOG(WARNING) << ""Scan of table "" << kCdcStateTableName.table_name() << "" failed: "" << status;
      failed = true;
    };
    options.columns = std::vector<std::string>{master::kCdcTabletId, master::kCdcStreamId,
        master::kCdcCheckpoint, master::kCdcLastReplicationTime};
    for (const auto& row : client::TableRange(**cdc_state_table_result, options)) {
      count++;
      auto tablet_id = row.column(master::kCdcTabletIdIdx).string_value();
      auto stream_id = row.column(master::kCdcStreamIdIdx).string_value();
      auto checkpoint = row.column(master::kCdcCheckpointIdx).string_value();
      std::string last_replicated_time_str;
      const auto& timestamp_ql_value = row.column(3);
      if (!timestamp_ql_value.IsNull()) {
        last_replicated_time_str = timestamp_ql_value.timestamp_value().ToFormattedString();
      }

      VLOG(1) << ""stream_id: "" << stream_id << "", tablet_id: "" << tablet_id
              << "", checkpoint: "" << checkpoint << "", last replicated time: ""
              << last_replicated_time_str;

      auto result = OpId::FromString(checkpoint);
      if (!result.ok()) {
        LOG(WARNING) << ""Read invalid op id "" << row.column(1).string_value()
                     << "" for tablet "" << tablet_id;
        continue;
      }

      auto index = (*result).index;
      auto it = tablet_min_checkpoint_index.find(tablet_id);
      if (it == tablet_min_checkpoint_index.end()) {
        tablet_min_checkpoint_index[tablet_id] = index;
      } else {
        if (index < it->second) {
          it->second = index;
        }
      }
    }
    if (failed) {
      RefreshCdcStateTable();
      continue;
    }
    LOG(INFO) << ""Read "" << count << "" records from "" << kCdcStateTableName.table_name();

    VLOG(3) << ""tablet_min_checkpoint_index size "" << tablet_min_checkpoint_index.size();
    for (const auto &elem : tablet_min_checkpoint_index) {
      auto tablet_id = elem.first;
      std::shared_ptr<tablet::TabletPeer> tablet_peer;

      Status s = tablet_manager_->GetTabletPeer(tablet_id, &tablet_peer);
      if (s.IsNotFound()) {
        VLOG(2) << ""Did not found tablet peer for tablet "" << tablet_id;
        continue;
      } else if (!IsTabletPeerLeader(tablet_peer)) {
        VLOG(2) << ""Tablet peer "" << tablet_peer->permanent_uuid()
                << "" is not the leader for tablet "" << tablet_id;
        continue;
      } else if (!s.ok()) {
        LOG(WARNING) << ""Error getting tablet_peer for tablet "" << tablet_id << "": "" << s;
        continue;
      }

      auto min_index = elem.second;
      s = tablet_peer->set_cdc_min_replicated_index(min_index);
      if (!s.ok()) {
        LOG(WARNING) << ""Unable to set cdc min index for tablet peer ""
                     << tablet_peer->permanent_uuid()
                     << "" and tablet "" << tablet_peer->tablet_id()
                     << "": "" << s;
      }
      LOG(INFO) << ""Updating followers for tablet "" << tablet_id << "" with index "" << min_index;
      WARN_NOT_OK(UpdatePeersCdcMinReplicatedIndex(tablet_id, min_index),
                  ""UpdatePeersCdcMinReplicatedIndex failed"");
    }
    LOG(INFO) << ""Done reading all the indices for all tablets and updating peers"";
  } while (sleep_while_not_stopped());
}

Result<client::internal::RemoteTabletPtr> CDCServiceImpl::GetRemoteTablet(
    const TabletId& tablet_id) {
  std::promise<Result<client::internal::RemoteTabletPtr>> tablet_lookup_promise;
  auto future = tablet_lookup_promise.get_future();
  auto callback = [&tablet_lookup_promise](
      const Result<client::internal::RemoteTabletPtr>& result) {
    tablet_lookup_promise.set_value(result);
  };

  auto start = CoarseMonoClock::Now();
  async_client_init_->client()->LookupTabletById(
      tablet_id,
      /* table =*/ nullptr,
      // In case this is a split parent tablet, it will be hidden so we need this flag to access it.
      master::IncludeInactive::kTrue,
      CoarseMonoClock::Now() + MonoDelta::FromMilliseconds(FLAGS_cdc_read_rpc_timeout_ms),
      callback, client::UseCache::kFalse);
  future.wait();

  auto duration = CoarseMonoClock::Now() - start;
  if (duration > (kMaxDurationForTabletLookup * 1ms)) {
    LOG(WARNING) << ""LookupTabletByKey took long time: "" << duration << "" ms"";
  }

  auto remote_tablet = VERIFY_RESULT(future.get());
  return remote_tablet;
}

Result<RemoteTabletServer *> CDCServiceImpl::GetLeaderTServer(const TabletId& tablet_id) {
  auto result = VERIFY_RESULT(GetRemoteTablet(tablet_id));

  auto ts = result->LeaderTServer();
  if (ts == nullptr) {
    return STATUS(NotFound, ""Tablet leader not found for tablet"", tablet_id);
  }
  return ts;
}

Status CDCServiceImpl::GetTServers(const TabletId& tablet_id,
                                   std::vector<client::internal::RemoteTabletServer*>* servers) {
  auto result = VERIFY_RESULT(GetRemoteTablet(tablet_id));

  result->GetRemoteTabletServers(servers);
  return Status::OK();
}

std::shared_ptr<CDCServiceProxy> CDCServiceImpl::GetCDCServiceProxy(RemoteTabletServer* ts) {
  auto hostport = HostPortFromPB(DesiredHostPort(
      ts->public_rpc_hostports(), ts->private_rpc_hostports(), ts->cloud_info(),
      async_client_init_->client()->cloud_info()));
  DCHECK(!hostport.host().empty());

  {
    SharedLock<decltype(mutex_)> l(mutex_);
    auto it = cdc_service_map_.find(hostport);
    if (it != cdc_service_map_.end()) {
      return it->second;
    }
  }

  auto cdc_service = std::make_shared<CDCServiceProxy>(&async_client_init_->client()->proxy_cache(),
                                                       hostport);
  {
    std::lock_guard<decltype(mutex_)> l(mutex_);
    auto it = cdc_service_map_.find(hostport);
    if (it != cdc_service_map_.end()) {
      return it->second;
    }
    cdc_service_map_.emplace(hostport, cdc_service);
  }
  return cdc_service;
}

void CDCServiceImpl::TabletLeaderGetChanges(const GetChangesRequestPB* req,
                                            GetChangesResponsePB* resp,
                                            std::shared_ptr<RpcContext> context,
                                            std::shared_ptr<tablet::TabletPeer> peer) {
  auto rpc_handle = rpcs_.Prepare();
  RPC_CHECK_AND_RETURN_ERROR(rpc_handle != rpcs_.InvalidHandle(),
      STATUS(Aborted,
          Format(""Could not create valid handle for GetChangesCDCRpc: tablet=$0, peer=$1"",
                 req->tablet_id(),
                 peer->permanent_uuid())),
      resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, *context.get());

  // Increment Proxy Metric.
  server_metrics_->cdc_rpc_proxy_count->Increment();

  // Forward this Request Info to the proper TabletServer.
  GetChangesRequestPB new_req;
  new_req.CopyFrom(*req);
  new_req.set_serve_as_proxy(false);
  CoarseTimePoint deadline = context->GetClientDeadline();
  if (deadline == CoarseTimePoint::max()) { // Not specified by user.
    deadline = CoarseMonoClock::now() + async_client_init_->client()->default_rpc_timeout();
  }
  *rpc_handle = CreateGetChangesCDCRpc(
      deadline,
      nullptr, /* RemoteTablet: will get this from 'new_req' */
      async_client_init_->client(),
      &new_req,
      [=] (Status status, GetChangesResponsePB&& new_resp) {
        auto retained = rpcs_.Unregister(rpc_handle);
        *resp = std::move(new_resp);
        RPC_STATUS_RETURN_ERROR(status, resp->mutable_error(), resp->error().code(),
                                *context.get());
        context->RespondSuccess();
      });
  (**rpc_handle).SendRpc();
}

void CDCServiceImpl::TabletLeaderGetCheckpoint(const GetCheckpointRequestPB* req,
                                               GetCheckpointResponsePB* resp,
                                               RpcContext* context,
                                               const std::shared_ptr<tablet::TabletPeer>& peer) {
  auto result = GetLeaderTServer(req->tablet_id());
  RPC_CHECK_AND_RETURN_ERROR(result.ok(), result.status(), resp->mutable_error(),
                             CDCErrorPB::TABLET_NOT_FOUND, *context);

  auto ts_leader = *result;
  // Check that tablet leader identified by master is not current tablet peer.
  // This can happen during tablet rebalance if master and tserver have different views of
  // leader. We need to avoid self-looping in this case.
  if (peer) {
    RPC_CHECK_NE_AND_RETURN_ERROR(ts_leader->permanent_uuid(), peer->permanent_uuid(),
                                  STATUS(IllegalState,
                                         Format(""Tablet leader changed: leader=$0, peer=$1"",
                                                ts_leader->permanent_uuid(),
                                                peer->permanent_uuid())),
                                  resp->mutable_error(), CDCErrorPB::NOT_LEADER, *context);
  }

  auto cdc_proxy = GetCDCServiceProxy(ts_leader);
  rpc::RpcController rpc;
  rpc.set_timeout(MonoDelta::FromMilliseconds(FLAGS_cdc_read_rpc_timeout_ms));
  // TODO(NIC): Change to GetCheckpointAsync like CDCPoller::DoPoll.
  auto status = cdc_proxy->GetCheckpoint(*req, resp, &rpc);
  RPC_STATUS_RETURN_ERROR(status, resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, *context);
  context->RespondSuccess();
}

void CDCServiceImpl::GetCheckpoint(const GetCheckpointRequestPB* req,
                                   GetCheckpointResponsePB* resp,
                                   RpcContext context) {
  if (!CheckOnline(req, resp, &context)) {
    return;
  }

  RPC_CHECK_AND_RETURN_ERROR(req->has_tablet_id(),
                             STATUS(InvalidArgument, ""Tablet ID is required to get CDC checkpoint""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);
  RPC_CHECK_AND_RETURN_ERROR(req->has_stream_id(),
                             STATUS(InvalidArgument, ""Stream ID is required to get CDC checkpoint""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  std::shared_ptr<tablet::TabletPeer> tablet_peer;
  Status s = tablet_manager_->GetTabletPeer(req->tablet_id(), &tablet_peer);

  if (s.IsNotFound() || !IsTabletPeerLeader(tablet_peer)) {
    // Forward GetChanges() to tablet leader. This happens often in Kubernetes setups.
    TabletLeaderGetCheckpoint(req, resp, &context, tablet_peer);
    return;
  }

  // Check that requested tablet_id is part of the CDC stream.
  ProducerTabletInfo producer_tablet = {"""" /* UUID */, req->stream_id(), req->tablet_id()};
  s = CheckTabletValidForStream(producer_tablet);
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::INVALID_REQUEST, context);

  auto session = async_client_init_->client()->NewSession();
  CoarseTimePoint deadline = context.GetClientDeadline();
  if (deadline == CoarseTimePoint::max()) { // Not specified by user.
    deadline = CoarseMonoClock::now() + async_client_init_->client()->default_rpc_timeout();
  }
  session->SetDeadline(deadline);

  auto result = GetLastCheckpoint(producer_tablet, session);
  RPC_CHECK_AND_RETURN_ERROR(result.ok(), result.status(), resp->mutable_error(),
                             CDCErrorPB::INTERNAL_ERROR, context);

  result->ToPB(resp->mutable_checkpoint()->mutable_op_id());
  context.RespondSuccess();
}

void CDCServiceImpl::UpdateCdcReplicatedIndex(const UpdateCdcReplicatedIndexRequestPB* req,
                                              UpdateCdcReplicatedIndexResponsePB* resp,
                                              rpc::RpcContext context) {
  if (!CheckOnline(req, resp, &context)) {
    return;
  }

  RPC_CHECK_AND_RETURN_ERROR(req->has_tablet_id(),
                             STATUS(InvalidArgument,
                                    ""Tablet ID is required to set the log replicated index""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  RPC_CHECK_AND_RETURN_ERROR(req->has_replicated_index(),
                             STATUS(InvalidArgument,
                                    ""Replicated index is required to set the log replicated index""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  std::shared_ptr<tablet::TabletPeer> tablet_peer;
  RPC_STATUS_RETURN_ERROR(tablet_manager_->GetTabletPeer(req->tablet_id(), &tablet_peer),
                          resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, context);

  RPC_CHECK_AND_RETURN_ERROR(tablet_peer->log_available(),
                             STATUS(TryAgain, ""Tablet peer is not ready to set its log cdc index""),
                             resp->mutable_error(),
                             CDCErrorPB::INTERNAL_ERROR,
                             context);

  RPC_STATUS_RETURN_ERROR(tablet_peer->set_cdc_min_replicated_index(req->replicated_index()),
                          resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, context);

  context.RespondSuccess();
}

  Result<OpId> CDCServiceImpl::TabletLeaderLatestEntryOpId(const TabletId& tablet_id) {
    auto ts_leader = VERIFY_RESULT(GetLeaderTServer(tablet_id));

    auto cdc_proxy = GetCDCServiceProxy(ts_leader);
    rpc::RpcController rpc;
    rpc.set_timeout(MonoDelta::FromMilliseconds(FLAGS_cdc_read_rpc_timeout_ms));
    GetLatestEntryOpIdRequestPB req;
    GetLatestEntryOpIdResponsePB resp;
    req.set_tablet_id(tablet_id);
    auto status = cdc_proxy->GetLatestEntryOpId(req, &resp, &rpc);
    if (!status.ok()) {
      // If we failed to get the latest entry op id, we try other tservers. The leader is guaranteed
      // to have the most up-to-date information, but for our purposes, it's ok to be slightly
      // behind.
      std::vector<client::internal::RemoteTabletServer *> servers;
      auto s = GetTServers(tablet_id, &servers);
      for (const auto& server : servers) {
        // We don't want to try the leader again.
        if (server->permanent_uuid() == ts_leader->permanent_uuid()) {
          continue;
        }
        auto follower_cdc_proxy = GetCDCServiceProxy(server);
        status = follower_cdc_proxy->GetLatestEntryOpId(req, &resp, &rpc);
        if (status.ok()) {
          return OpId::FromPB(resp.op_id());
        }
      }
      DCHECK(!status.ok());
      return status;
    }
    return OpId::FromPB(resp.op_id());
  }

void CDCServiceImpl::GetLatestEntryOpId(const GetLatestEntryOpIdRequestPB* req,
                                        GetLatestEntryOpIdResponsePB* resp,
                                        rpc::RpcContext context) {
  std::shared_ptr<tablet::TabletPeer> tablet_peer;
  Status s = tablet_manager_->GetTabletPeer(req->tablet_id(), &tablet_peer);
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, context);

  if (!tablet_peer->log_available()) {
    const string err_message = strings::Substitute(""Unable to get the latest entry op id from ""
        ""peer $0 and tablet $1 because its log object hasn't been initialized"",
        tablet_peer->permanent_uuid(), tablet_peer->tablet_id());
    LOG(WARNING) << err_message;
    SetupErrorAndRespond(resp->mutable_error(),
                         STATUS(ServiceUnavailable, err_message),
                         CDCErrorPB::INTERNAL_ERROR,
                         &context);
    return;
  }
  OpId op_id = tablet_peer->log()->GetLatestEntryOpId();
  op_id.ToPB(resp->mutable_op_id());
  context.RespondSuccess();
}

void CDCServiceImpl::BootstrapProducer(const BootstrapProducerRequestPB* req,
                                       BootstrapProducerResponsePB* resp,
                                       rpc::RpcContext context) {
  LOG(INFO) << ""Received BootstrapProducer request "" << req->ShortDebugString();
  RPC_CHECK_AND_RETURN_ERROR(req->table_ids().size() > 0,
                             STATUS(InvalidArgument, ""Table ID is required to create CDC stream""),
                             resp->mutable_error(),
                             CDCErrorPB::INVALID_REQUEST,
                             context);

  std::shared_ptr<yb::client::TableHandle> cdc_state_table;

  std::vector<client::YBOperationPtr> ops;
  auto session = async_client_init_->client()->NewSession();

  // Used to delete streams in case of failure.
  std::vector<CDCStreamId> created_cdc_streams;
  std::vector<ProducerTabletInfo> producer_entries_modified;
  auto scope_exit = ScopeExit([this, &created_cdc_streams, &producer_entries_modified] {
    if (!created_cdc_streams.empty()) {
      Status s = async_client_init_->client()->DeleteCDCStream(created_cdc_streams);
      if (!s.ok()) {
        LOG(WARNING) << ""Unable to delete streams "" << JoinCSVLine(created_cdc_streams)
                     << "": "" << s;
      }
    }

    // For all tablets we modified state for, reverse those changes if the operation failed
    // halfway through.
    if (producer_entries_modified.empty()) {
      return;
    }
    TabletCheckpoints tablet_checkpoints;
    {
      SharedLock<decltype(mutex_)> l(mutex_);
      tablet_checkpoints = tablet_checkpoints_;
    }
    for (const auto& entry : producer_entries_modified) {
      tablet_checkpoints.get<TabletTag>().erase(entry.tablet_id);
      WARN_NOT_OK(
          UpdatePeersCdcMinReplicatedIndex(entry.tablet_id, numeric_limits<uint64_t>::max()),
                                           ""Unable to update tablet "" + entry.tablet_id);
    }
    std::lock_guard<decltype(mutex_)> l(mutex_);
    tablet_checkpoints_ = tablet_checkpoints;
  });

  std::vector<CDCStreamId> bootstrap_ids;

  for (const auto& table_id : req->table_ids()) {
    std::shared_ptr<client::YBTable> table;
    Status s = async_client_init_->client()->OpenTable(table_id, &table);
    RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::TABLE_NOT_FOUND, context);

    // Generate a bootstrap id by calling CreateCDCStream, and also setup the stream in the master.
    // If the consumer's master sends a CreateCDCStream with a bootstrap id, the producer's master
    // will verify that the stream id exists and return success if it does since everything else
    // has already been done by this call.
    std::unordered_map<std::string, std::string> options;
    options.reserve(2);
    options.emplace(cdc::kRecordType, CDCRecordType_Name(cdc::CDCRecordType::CHANGE));
    options.emplace(cdc::kRecordFormat, CDCRecordFormat_Name(cdc::CDCRecordFormat::WAL));

    // Mark this stream as being bootstrapped, to help in finding dangling streams.
    auto result = async_client_init_->client()->CreateCDCStream(table_id, options, false);
    RPC_CHECK_AND_RETURN_ERROR(result.ok(), result.status(), resp->mutable_error(),
                               CDCErrorPB::INTERNAL_ERROR, context);
    const std::string& bootstrap_id = *result;
    created_cdc_streams.push_back(bootstrap_id);

    if (cdc_state_table == nullptr) {
      auto res = GetCdcStateTable();
      RPC_CHECK_AND_RETURN_ERROR(res.ok(), res.status(), resp->mutable_error(),
          CDCErrorPB::INTERNAL_ERROR, context);
      cdc_state_table = *res;
    }

    google::protobuf::RepeatedPtrField<master::TabletLocationsPB> tablets;
    s = async_client_init_->client()->GetTabletsFromTableId(table_id, 0, &tablets);
    RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::TABLE_NOT_FOUND, context);

    // For each tablet, create a row in cdc_state table containing the generated bootstrap id, and
    // the latest op id in the logs.
    for (const auto &tablet : tablets) {
      std::shared_ptr<tablet::TabletPeer> tablet_peer;
      OpId op_id;

      s = tablet_manager_->GetTabletPeer(tablet.tablet_id(), &tablet_peer);
      if (!s.ok()) {
        auto result = TabletLeaderLatestEntryOpId(tablet.tablet_id());
        RPC_CHECK_AND_RETURN_ERROR(result.ok(), result.status(), resp->mutable_error(),
            CDCErrorPB::INTERNAL_ERROR, context);
        op_id = *result;
      } else {
        if (!tablet_peer->log_available()) {
          const string err_message = strings::Substitute(""Unable to get the latest entry op id ""
              ""from peer $0 and tablet $1 because its log object hasn't been initialized"",
              tablet_peer->permanent_uuid(), tablet_peer->tablet_id());
          LOG(WARNING) << err_message;
          SetupErrorAndRespond(resp->mutable_error(),
                               STATUS(ServiceUnavailable, err_message),
                               CDCErrorPB::INTERNAL_ERROR,
                               &context);
          return;
        }
        op_id = tablet_peer->log()->GetLatestEntryOpId();
        RPC_STATUS_RETURN_ERROR(UpdatePeersCdcMinReplicatedIndex(tablet.tablet_id(), op_id.index),
                                resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR,
                                context);
      }

      const auto op = cdc_state_table->NewWriteOp(QLWriteRequestPB::QL_STMT_INSERT);
      auto *const write_req = op->mutable_request();

      QLAddStringHashValue(write_req, tablet.tablet_id());
      QLAddStringRangeValue(write_req, bootstrap_id);
      cdc_state_table->AddStringColumnValue(write_req, master::kCdcCheckpoint, op_id.ToString());
      ops.push_back(std::move(op));

      {
        ProducerTabletInfo producer_tablet{
          """" /* Universe UUID */, bootstrap_id, tablet.tablet_id()};
        auto now = CoarseMonoClock::Now();
        TabletCheckpoint sent_checkpoint({op_id, now});
        TabletCheckpoint commit_checkpoint({op_id, now});
        std::lock_guard<decltype(mutex_)> l(mutex_);
        tablet_checkpoints_.emplace(producer_tablet, commit_checkpoint, sent_checkpoint);
        producer_entries_modified.push_back(producer_tablet);
      }
    }
    bootstrap_ids.push_back(std::move(bootstrap_id));
  }
  CoarseTimePoint deadline = context.GetClientDeadline();
  if (deadline == CoarseTimePoint::max()) { // Not specified by user.
    deadline = CoarseMonoClock::now() + async_client_init_->client()->default_rpc_timeout();
  }
  session->SetDeadline(deadline);
  Status s = RefreshCacheOnFail(session->ApplyAndFlush(ops));
  RPC_STATUS_RETURN_ERROR(s, resp->mutable_error(), CDCErrorPB::INTERNAL_ERROR, context);

  for (const auto& bootstrap_id : bootstrap_ids) {
    resp->add_cdc_bootstrap_ids(bootstrap_id);
  }
  // Clear these vectors so no changes are reversed by scope_exit since we succeeded.
  created_cdc_streams.clear();
  producer_entries_modified.clear();
  context.RespondSuccess();
}

void CDCServiceImpl::Shutdown() {
  if (async_client_init_) {
    async_client_init_->Shutdown();
    rpcs_.Shutdown();
    {
      std::lock_guard<decltype(mutex_)> l(mutex_);
      cdc_service_stopped_ = true;
      cdc_state_table_ = nullptr;
    }
    if (update_peers_and_metrics_thread_) {
      update_peers_and_metrics_thread_->join();
    }
    async_client_init_ = boost::none;
  }
}

Result<OpId> CDCServiceImpl::GetLastCheckpoint(
    const ProducerTabletInfo& producer_tablet,
    const std::shared_ptr<client::YBSession>& session) {
  {
    SharedLock<decltype(mutex_)> l(mutex_);
    auto it = tablet_checkpoints_.find(producer_tablet);
    if (it != tablet_checkpoints_.end()) {
      // Use checkpoint from cache only if it is current.
      if (it->cdc_state_checkpoint.op_id.index > 0 &&
          CoarseMonoClock::Now() - it->cdc_state_checkpoint.last_update_time <=
              (FLAGS_cdc_state_checkpoint_update_interval_ms * 1ms)) {
        return it->cdc_state_checkpoint.op_id;
      }
    }
  }

  auto cdc_state_table_result = GetCdcStateTable();
  RETURN_NOT_OK(cdc_state_table_result);

  const auto op = (*cdc_state_table_result)->NewReadOp();
  auto* const req = op->mutable_request();
  DCHECK(!producer_tablet.stream_id.empty() && !producer_tablet.tablet_id.empty());
  QLAddStringHashValue(req, producer_tablet.tablet_id);

  auto cond = req->mutable_where_expr()->mutable_condition();
  cond->set_op(QLOperator::QL_OP_AND);
  QLAddStringCondition(cond, Schema::first_column_id() + master::kCdcStreamIdIdx,
      QL_OP_EQUAL, producer_tablet.stream_id);
  req->mutable_column_refs()->add_ids(Schema::first_column_id() + master::kCdcTabletIdIdx);
  req->mutable_column_refs()->add_ids(Schema::first_column_id() + master::kCdcStreamIdIdx);
  (*cdc_state_table_result)->AddColumns({master::kCdcCheckpoint}, req);

  RETURN_NOT_OK(RefreshCacheOnFail(session->ReadSync(op)));
  auto row_block = ql::RowsResult(op.get()).GetRowBlock();
  if (row_block->row_count() == 0) {
    return OpId(0, 0);
  }

  DCHECK_EQ(row_block->row_count(), 1);
  DCHECK_EQ(row_block->row(0).column(0).type(), InternalType::kStringValue);

  return OpId::FromString(row_block->row(0).column(0).string_value());
}

Status CDCServiceImpl::UpdateCheckpoint(const ProducerTabletInfo& producer_tablet,
                                        const OpId& sent_op_id,
                                        const OpId& commit_op_id,
                                        const std::shared_ptr<client::YBSession>& session,
                                        uint64_t last_record_hybrid_time) {
  bool update_cdc_state = true;
  auto now = CoarseMonoClock::Now();
  TabletCheckpoint sent_checkpoint({sent_op_id, now});
  TabletCheckpoint commit_checkpoint({commit_op_id, now});

  {
    std::lock_guard<decltype(mutex_)> l(mutex_);
    auto it = tablet_checkpoints_.find(producer_tablet);
    if (it != tablet_checkpoints_.end()) {
      it->sent_checkpoint = sent_checkpoint;

      if (commit_op_id.index > 0) {
        it->cdc_state_checkpoint.op_id = commit_op_id;
      }

      // Check if we need to update cdc_state table.
      if (now - it->cdc_state_checkpoint.last_update_time <=
          (FLAGS_cdc_state_checkpoint_update_interval_ms * 1ms)) {
        update_cdc_state = false;
      } else {
        it->cdc_state_checkpoint.last_update_time = now;
      }
    } else {
      tablet_checkpoints_.emplace(producer_tablet, commit_checkpoint, sent_checkpoint);
    }
  }

  if (update_cdc_state) {
    auto cdc_state = VERIFY_RESULT(GetCdcStateTable());
    const auto op = cdc_state->NewUpdateOp();
    auto* const req = op->mutable_request();
    DCHECK(!producer_tablet.stream_id.empty() && !producer_tablet.tablet_id.empty());
    QLAddStringHashValue(req, producer_tablet.tablet_id);
    QLAddStringRangeValue(req, producer_tablet.stream_id);

    cdc_state->AddStringColumnValue(req, master::kCdcCheckpoint, commit_op_id.ToString());
    // If we have a last record hybrid time, use that for physical time. If not, it means we're
    // caught up, so the current time.
    uint64_t last_replication_time_micros = last_record_hybrid_time != 0 ?
        HybridTime(last_record_hybrid_time).GetPhysicalValueMicros() : GetCurrentTimeMicros();
    cdc_state->AddTimestampColumnValue(req, master::kCdcLastReplicationTime,
                                       last_replication_time_micros);
    // Only perform the update if we have a row in cdc_state to prevent a race condition where
    // a stream is deleted and then this logic inserts entries in cdc_state from that deleted
    // stream.
    auto* condition = req->mutable_if_expr()->mutable_condition();
    condition->set_op(QL_OP_EXISTS);
    RETURN_NOT_OK(RefreshCacheOnFail(session->ApplyAndFlush(op)));
  }

  return Status::OK();
}

OpId CDCServiceImpl::GetMinSentCheckpointForTablet(const std::string& tablet_id) {
  OpId min_op_id = OpId::Max();
  auto now = CoarseMonoClock::Now();

  SharedLock<rw_spinlock> l(mutex_);
  auto it_range = tablet_checkpoints_.get<TabletTag>().equal_range(tablet_id);
  if (it_range.first == it_range.second) {
    LOG(WARNING) << ""Tablet ID not found in stream_tablets map: "" << tablet_id;
    return min_op_id;
  }

  auto cdc_checkpoint_opid_interval = FLAGS_cdc_checkpoint_opid_interval_ms * 1ms;
  for (auto it = it_range.first; it != it_range.second; ++it) {
    // We don't want to include streams that are not being actively polled.
    // So, if the stream has not been polled in the last x seconds,
    // then we ignore that stream while calculating min op ID.
    if (now - it->sent_checkpoint.last_update_time <= cdc_checkpoint_opid_interval &&
        it->sent_checkpoint.op_id.index < min_op_id.index) {
      min_op_id = it->sent_checkpoint.op_id;
    }
  }
  return min_op_id;
}

std::shared_ptr<CDCTabletMetrics> CDCServiceImpl::GetCDCTabletMetrics(
    const ProducerTabletInfo& producer,
    std::shared_ptr<tablet::TabletPeer> tablet_peer) {
  // 'nullptr' not recommended: using for tests.
  if (tablet_peer == nullptr) {
    auto status = tablet_manager_->GetTabletPeer(producer.tablet_id, &tablet_peer);
    if (!status.ok() || tablet_peer == nullptr) return nullptr;
  }

  auto tablet = tablet_peer->shared_tablet();
  if (tablet == nullptr) return nullptr;

  std::string key = ""CDCMetrics::"" + producer.stream_id;
  std::shared_ptr<void> metrics_raw = tablet->GetAdditionalMetadata(key);
  if (metrics_raw == nullptr) {
    //  Create a new METRIC_ENTITY_cdc here.
    MetricEntity::AttributeMap attrs;
    {
      SharedLock<rw_spinlock> l(mutex_);
      auto raft_group_metadata = tablet_peer->tablet()->metadata();
      attrs[""table_id""] = raft_group_metadata->table_id();
      attrs[""namespace_name""] = raft_group_metadata->namespace_name();
      attrs[""table_name""] = raft_group_metadata->table_name();
      attrs[""stream_id""] = producer.stream_id;
    }
    auto entity = METRIC_ENTITY_cdc.Instantiate(metric_registry_, producer.MetricsString(), attrs);
    metrics_raw = std::make_shared<CDCTabletMetrics>(entity);
    // Adding the new metric to the tablet so it maintains the same lifetime scope.
    tablet->AddAdditionalMetadata(key, metrics_raw);
  }

  return std::static_pointer_cast<CDCTabletMetrics>(metrics_raw);
}

OpId CDCServiceImpl::GetMinAppliedCheckpointForTablet(
    const std::string& tablet_id,
    const std::shared_ptr<client::YBSession>& session) {

  OpId min_op_id = OpId::Max();
  bool min_op_id_updated = false;

  {
    SharedLock<rw_spinlock> l(mutex_);
    // right => multimap where keys are tablet_ids and values are stream_ids.
    // left => multimap where keys are stream_ids and values are tablet_ids.
    auto it_range = tablet_checkpoints_.get<TabletTag>().equal_range(tablet_id);
    if (it_range.first != it_range.second) {
      // Iterate over all the streams for this tablet.
      for (auto it = it_range.first; it != it_range.second; ++it) {
        if (it->cdc_state_checkpoint.op_id.index < min_op_id.index) {
          min_op_id = it->cdc_state_checkpoint.op_id;
          min_op_id_updated = true;
        }
      }
    } else {
      VLOG(2) << ""Didn't find any streams for tablet "" << tablet_id;
    }
  }
  if (min_op_id_updated) {
    return min_op_id;
  }

  LOG(INFO) << ""Unable to find checkpoint for tablet "" << tablet_id << "" in the cache"";
  min_op_id = OpId();

  // We didn't find any streams for this tablet in the cache.
  // Let's read the cdc_state table and save this information in the cache so that it can be used
  // next time.
  auto cdc_state_table_result = GetCdcStateTable();
  if (!cdc_state_table_result.ok()) {
    YB_LOG_EVERY_N(WARNING, 30) << ""Unable to open table "" << kCdcStateTableName.table_name();
    // Return consensus::MinimumOpId()
    return min_op_id;
  }

  const auto op = (*cdc_state_table_result)->NewReadOp();
  auto* const req = op->mutable_request();
  QLAddStringHashValue(req, tablet_id);
  (*cdc_state_table_result)->AddColumns({master::kCdcCheckpoint, master::kCdcStreamId}, req);
  if (!session->ApplyAndFlush(op).ok()) {
    YB_LOG_EVERY_N(WARNING, 30) << ""Unable to read table "" << kCdcStateTableName.table_name();
    RefreshCdcStateTable();
    // Return consensus::MinimumOpId()
    return min_op_id;
  }

  auto row_block = ql::RowsResult(op.get()).GetRowBlock();
  if (row_block->row_count() == 0) {
    YB_LOG_EVERY_N(WARNING, 30) << ""Unable to find any cdc record for tablet "" << tablet_id
                                 << "" in table "" << kCdcStateTableName.table_name();
    // Return consensus::MinimumOpId()
    return min_op_id;
  }

  DCHECK_EQ(row_block->row(0).column(0).type(), InternalType::kStringValue);

  auto min_index = consensus::MaximumOpId().index();
  for (const auto& row : row_block->rows()) {
    std::string stream_id = row.column(1).string_value();
    auto result = OpId::FromString(row.column(0).string_value());
    if (!result.ok()) {
      LOG(WARNING) << ""Invalid checkpoint "" << row.column(0).string_value()
                   << "" for tablet "" << tablet_id << "" and stream "" << stream_id;
      continue;
    }

    auto index = (*result).index;
    auto term = (*result).term;

    if (index < min_index) {
      min_op_id.term = term;
      min_op_id.index = index;
      min_index = index;
    }

    // If the checkpoints cache hasn't been updated yet, update it so we don't have to read
    // the table next time we get a request for this tablet.
    std::lock_guard<rw_spinlock> l(mutex_);
    ProducerTabletInfo producer_tablet{"""" /*UUID*/, stream_id, tablet_id};
    auto cached_checkpoint = tablet_checkpoints_.find(producer_tablet);
    if (cached_checkpoint == tablet_checkpoints_.end()) {
      std::chrono::time_point<CoarseMonoClock> min_clock =
          CoarseMonoClock::time_point(CoarseMonoClock::duration(0));
      OpId checkpoint_op_id(term, index);
      TabletCheckpoint commit_checkpoint({checkpoint_op_id, min_clock});
      tablet_checkpoints_.emplace(producer_tablet, commit_checkpoint, commit_checkpoint);
    }
  }

  return min_op_id;
}

Result<std::shared_ptr<StreamMetadata>> CDCServiceImpl::GetStream(const std::string& stream_id) {
  auto stream = GetStreamMetadataFromCache(stream_id);
  if (stream != nullptr) {
    return stream;
  }

  // Look up stream in sys catalog.
  TableId table_id;
  std::unordered_map<std::string, std::string> options;
  RETURN_NOT_OK(async_client_init_->client()->GetCDCStream(stream_id, &table_id, &options));

  auto stream_metadata = std::make_shared<StreamMetadata>();;
  stream_metadata->table_id = table_id;
  for (const auto& option : options) {
    if (option.first == kRecordType) {
      SCHECK(CDCRecordType_Parse(option.second, &stream_metadata->record_type),
             IllegalState, ""CDC record type parsing error"");
    } else if (option.first == kRecordFormat) {
      SCHECK(CDCRecordFormat_Parse(option.second, &stream_metadata->record_format),
             IllegalState, ""CDC record format parsing error"");
    } else {
      LOG(WARNING) << ""Unsupported CDC option: "" << option.first;
    }
  }

  AddStreamMetadataToCache(stream_id, stream_metadata);
  return stream_metadata;
}

void CDCServiceImpl::AddStreamMetadataToCache(const std::string& stream_id,
                                              const std::shared_ptr<StreamMetadata>& metadata) {
  std::lock_guard<decltype(mutex_)> l(mutex_);
  stream_metadata_.emplace(stream_id, metadata);
}

std::shared_ptr<StreamMetadata> CDCServiceImpl::GetStreamMetadataFromCache(
    const std::string& stream_id) {
  SharedLock<decltype(mutex_)> l(mutex_);
  auto it = stream_metadata_.find(stream_id);
  if (it != stream_metadata_.end()) {
    return it->second;
  } else {
    return nullptr;
  }
}

MemTrackerPtr CDCServiceImpl::GetMemTracker(
    const std::shared_ptr<tablet::TabletPeer>& tablet_peer,
    const ProducerTabletInfo& producer_info) {
  {
    SharedLock<decltype(mutex_)> l(mutex_);
    auto it = tablet_checkpoints_.find(producer_info);
    if (it == tablet_checkpoints_.end()) {
      return nullptr;
    }
    if (it->mem_tracker) {
      return it->mem_tracker;
    }
  }
  std::lock_guard<rw_spinlock> l(mutex_);
  auto it = tablet_checkpoints_.find(producer_info);
  if (it->mem_tracker) {
    return it->mem_tracker;
  }
  auto cdc_mem_tracker = MemTracker::FindOrCreateTracker(
      ""CDC"", tablet_peer->tablet()->mem_tracker());
  const_cast<MemTrackerPtr&>(it->mem_tracker) = MemTracker::FindOrCreateTracker(
      producer_info.stream_id, cdc_mem_tracker);
  return it->mem_tracker;
}

Status CDCServiceImpl::CheckTabletValidForStream(const ProducerTabletInfo& info) {
  {
    SharedLock<rw_spinlock> l(mutex_);
    if (tablet_checkpoints_.count(info) != 0) {
      return Status::OK();
    }
    const auto& stream_index = tablet_checkpoints_.get<StreamTag>();
    if (stream_index.find(info.stream_id) != stream_index.end()) {
      // Did not find matching tablet ID.
      // TODO: Add the split tablets in during tablet split?
      LOG(INFO) << ""Tablet ID "" << info.tablet_id << "" is not part of stream ID "" << info.stream_id
                << "". Repopulating tablet list for this stream."";
    }
  }

  // If we don't recognize the stream_id, populate our full tablet list for this stream.
  auto tablets = VERIFY_RESULT(GetTablets(info.stream_id));
  bool found = false;
  {
    std::lock_guard<rw_spinlock> l(mutex_);
    for (const auto &tablet : tablets) {
      // Add every tablet in the stream.
      ProducerTabletInfo producer_info{info.universe_uuid, info.stream_id, tablet.tablet_id()};
      auto it = tablet_checkpoints_.find(producer_info);
      if (it == tablet_checkpoints_.end()) {
        // This is a new tablet, lets add it to the map.
        tablet_checkpoints_.emplace(producer_info, TabletCheckpoint(), TabletCheckpoint());
      }
      // If this is the tablet that the user requested.
      if (tablet.tablet_id() == info.tablet_id) {
        found = true;
      }
    }
  }
  return found ? Status::OK()
               : STATUS_FORMAT(InvalidArgument, ""Tablet ID $0 is not part of stream ID $1"",
                               info.tablet_id, info.stream_id);
}

}  // namespace cdc
}  // namespace yb
",16206,True,3296.1322378301747,median
"// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html


#include ""precomp.hpp""
#include ""opencl_kernels_core.hpp""
#include ""stat.hpp""

/****************************************************************************************\\
*                                         norm                                           *
\\****************************************************************************************/

namespace cv { namespace hal {

extern const uchar popCountTable[256] =
{
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
};

static const uchar popCountTable2[] =
{
    0, 1, 1, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3,
    1, 2, 2, 2, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 1, 2, 2, 2, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3,
    1, 2, 2, 2, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4,
    2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4,
    1, 2, 2, 2, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4,
    2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4,
    1, 2, 2, 2, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4,
    2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4, 2, 3, 3, 3, 3, 4, 4, 4, 3, 4, 4, 4, 3, 4, 4, 4
};

static const uchar popCountTable4[] =
{
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
};


int normHamming(const uchar* a, int n, int cellSize)
{
    if( cellSize == 1 )
        return normHamming(a, n);
    const uchar* tab = 0;
    if( cellSize == 2 )
        tab = popCountTable2;
    else if( cellSize == 4 )
        tab = popCountTable4;
    else
        return -1;
    int i = 0;
    int result = 0;
#if CV_SIMD
    v_uint64 t = vx_setzero_u64();
    if ( cellSize == 2)
    {
        v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x55));
        for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
        {
            v_uint16 a0 = v_reinterpret_as_u16(vx_load(a + i));
            t += v_popcount(v_reinterpret_as_u64((a0 | (a0 >> 1)) & mask));
        }
    }
    else    // cellSize == 4
    {
        v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x11));
        for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
        {
            v_uint16 a0 = v_reinterpret_as_u16(vx_load(a + i));
            v_uint16 a1 = a0 | (a0 >> 2);
            t += v_popcount(v_reinterpret_as_u64((a1 | (a1 >> 1)) & mask));

        }
    }
    result += (int)v_reduce_sum(t);
    vx_cleanup();
#elif CV_ENABLE_UNROLLED
    for( ; i <= n - 4; i += 4 )
        result += tab[a[i]] + tab[a[i+1]] + tab[a[i+2]] + tab[a[i+3]];
#endif
    for( ; i < n; i++ )
        result += tab[a[i]];
    return result;
}

int normHamming(const uchar* a, const uchar* b, int n, int cellSize)
{
    if( cellSize == 1 )
        return normHamming(a, b, n);
    const uchar* tab = 0;
    if( cellSize == 2 )
        tab = popCountTable2;
    else if( cellSize == 4 )
        tab = popCountTable4;
    else
        return -1;
    int i = 0;
    int result = 0;
#if CV_SIMD
    v_uint64 t = vx_setzero_u64();
    if ( cellSize == 2)
    {
        v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x55));
        for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
        {
            v_uint16 ab0 = v_reinterpret_as_u16(vx_load(a + i) ^ vx_load(b + i));
            t += v_popcount(v_reinterpret_as_u64((ab0 | (ab0 >> 1)) & mask));
        }
    }
    else    // cellSize == 4
    {
        v_uint16 mask = v_reinterpret_as_u16(vx_setall_u8(0x11));
        for(; i <= n - v_uint8::nlanes; i += v_uint8::nlanes)
        {
            v_uint16 ab0 = v_reinterpret_as_u16(vx_load(a + i) ^ vx_load(b + i));
            v_uint16 ab1 = ab0 | (ab0 >> 2);
            t += v_popcount(v_reinterpret_as_u64((ab1 | (ab1 >> 1)) & mask));
        }
    }
    result += (int)v_reduce_sum(t);
    vx_cleanup();
#elif CV_ENABLE_UNROLLED
    for( ; i <= n - 4; i += 4 )
        result += tab[a[i] ^ b[i]] + tab[a[i+1] ^ b[i+1]] +
                tab[a[i+2] ^ b[i+2]] + tab[a[i+3] ^ b[i+3]];
#endif
    for( ; i < n; i++ )
        result += tab[a[i] ^ b[i]];
    return result;
}

float normL2Sqr_(const float* a, const float* b, int n)
{
    int j = 0; float d = 0.f;
#if CV_SIMD
    v_float32 v_d0 = vx_setzero_f32(), v_d1 = vx_setzero_f32();
    v_float32 v_d2 = vx_setzero_f32(), v_d3 = vx_setzero_f32();
    for (; j <= n - 4 * v_float32::nlanes; j += 4 * v_float32::nlanes)
    {
        v_float32 t0 = vx_load(a + j) - vx_load(b + j);
        v_float32 t1 = vx_load(a + j + v_float32::nlanes) - vx_load(b + j + v_float32::nlanes);
        v_float32 t2 = vx_load(a + j + 2 * v_float32::nlanes) - vx_load(b + j + 2 * v_float32::nlanes);
        v_float32 t3 = vx_load(a + j + 3 * v_float32::nlanes) - vx_load(b + j + 3 * v_float32::nlanes);
        v_d0 = v_muladd(t0, t0, v_d0);
        v_d1 = v_muladd(t1, t1, v_d1);
        v_d2 = v_muladd(t2, t2, v_d2);
        v_d3 = v_muladd(t3, t3, v_d3);
    }
    d = v_reduce_sum(v_d0 + v_d1 + v_d2 + v_d3);
#endif
    for( ; j < n; j++ )
    {
        float t = a[j] - b[j];
        d += t*t;
    }
    return d;
}


float normL1_(const float* a, const float* b, int n)
{
    int j = 0; float d = 0.f;
#if CV_SIMD
    v_float32 v_d0 = vx_setzero_f32(), v_d1 = vx_setzero_f32();
    v_float32 v_d2 = vx_setzero_f32(), v_d3 = vx_setzero_f32();
    for (; j <= n - 4 * v_float32::nlanes; j += 4 * v_float32::nlanes)
    {
        v_d0 += v_absdiff(vx_load(a + j), vx_load(b + j));
        v_d1 += v_absdiff(vx_load(a + j + v_float32::nlanes), vx_load(b + j + v_float32::nlanes));
        v_d2 += v_absdiff(vx_load(a + j + 2 * v_float32::nlanes), vx_load(b + j + 2 * v_float32::nlanes));
        v_d3 += v_absdiff(vx_load(a + j + 3 * v_float32::nlanes), vx_load(b + j + 3 * v_float32::nlanes));
    }
    d = v_reduce_sum(v_d0 + v_d1 + v_d2 + v_d3);
#endif
    for( ; j < n; j++ )
        d += std::abs(a[j] - b[j]);
    return d;
}

int normL1_(const uchar* a, const uchar* b, int n)
{
    int j = 0, d = 0;
#if CV_SIMD
    for (; j <= n - 4 * v_uint8::nlanes; j += 4 * v_uint8::nlanes)
        d += v_reduce_sad(vx_load(a + j), vx_load(b + j)) +
             v_reduce_sad(vx_load(a + j + v_uint8::nlanes), vx_load(b + j + v_uint8::nlanes)) +
             v_reduce_sad(vx_load(a + j + 2 * v_uint8::nlanes), vx_load(b + j + 2 * v_uint8::nlanes)) +
             v_reduce_sad(vx_load(a + j + 3 * v_uint8::nlanes), vx_load(b + j + 3 * v_uint8::nlanes));
#endif
    for( ; j < n; j++ )
        d += std::abs(a[j] - b[j]);
    return d;
}

}} //cv::hal

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

namespace cv
{

template<typename T, typename ST> int
normInf_(const T* src, const uchar* mask, ST* _result, int len, int cn)
{
    ST result = *_result;
    if( !mask )
    {
        result = std::max(result, normInf<T, ST>(src, len*cn));
    }
    else
    {
        for( int i = 0; i < len; i++, src += cn )
            if( mask[i] )
            {
                for( int k = 0; k < cn; k++ )
                    result = std::max(result, ST(cv_abs(src[k])));
            }
    }
    *_result = result;
    return 0;
}

template<typename T, typename ST> int
normL1_(const T* src, const uchar* mask, ST* _result, int len, int cn)
{
    ST result = *_result;
    if( !mask )
    {
        result += normL1<T, ST>(src, len*cn);
    }
    else
    {
        for( int i = 0; i < len; i++, src += cn )
            if( mask[i] )
            {
                for( int k = 0; k < cn; k++ )
                    result += cv_abs(src[k]);
            }
    }
    *_result = result;
    return 0;
}

template<typename T, typename ST> int
normL2_(const T* src, const uchar* mask, ST* _result, int len, int cn)
{
    ST result = *_result;
    if( !mask )
    {
        result += normL2Sqr<T, ST>(src, len*cn);
    }
    else
    {
        for( int i = 0; i < len; i++, src += cn )
            if( mask[i] )
            {
                for( int k = 0; k < cn; k++ )
                {
                    T v = src[k];
                    result += (ST)v*v;
                }
            }
    }
    *_result = result;
    return 0;
}

template<typename T, typename ST> int
normDiffInf_(const T* src1, const T* src2, const uchar* mask, ST* _result, int len, int cn)
{
    ST result = *_result;
    if( !mask )
    {
        result = std::max(result, normInf<T, ST>(src1, src2, len*cn));
    }
    else
    {
        for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
            if( mask[i] )
            {
                for( int k = 0; k < cn; k++ )
                    result = std::max(result, (ST)std::abs(src1[k] - src2[k]));
            }
    }
    *_result = result;
    return 0;
}

template<typename T, typename ST> int
normDiffL1_(const T* src1, const T* src2, const uchar* mask, ST* _result, int len, int cn)
{
    ST result = *_result;
    if( !mask )
    {
        result += normL1<T, ST>(src1, src2, len*cn);
    }
    else
    {
        for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
            if( mask[i] )
            {
                for( int k = 0; k < cn; k++ )
                    result += std::abs(src1[k] - src2[k]);
            }
    }
    *_result = result;
    return 0;
}

template<typename T, typename ST> int
normDiffL2_(const T* src1, const T* src2, const uchar* mask, ST* _result, int len, int cn)
{
    ST result = *_result;
    if( !mask )
    {
        result += normL2Sqr<T, ST>(src1, src2, len*cn);
    }
    else
    {
        for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
            if( mask[i] )
            {
                for( int k = 0; k < cn; k++ )
                {
                    ST v = src1[k] - src2[k];
                    result += v*v;
                }
            }
    }
    *_result = result;
    return 0;
}

#define CV_DEF_NORM_FUNC(L, suffix, type, ntype) \\
    static int norm##L##_##suffix(const type* src, const uchar* mask, ntype* r, int len, int cn) \\
{ return norm##L##_(src, mask, r, len, cn); } \\
    static int normDiff##L##_##suffix(const type* src1, const type* src2, \\
    const uchar* mask, ntype* r, int len, int cn) \\
{ return normDiff##L##_(src1, src2, mask, r, (int)len, cn); }

#define CV_DEF_NORM_ALL(suffix, type, inftype, l1type, l2type) \\
    CV_DEF_NORM_FUNC(Inf, suffix, type, inftype) \\
    CV_DEF_NORM_FUNC(L1, suffix, type, l1type) \\
    CV_DEF_NORM_FUNC(L2, suffix, type, l2type)

CV_DEF_NORM_ALL(8u, uchar, int, int, int)
CV_DEF_NORM_ALL(8s, schar, int, int, int)
CV_DEF_NORM_ALL(16u, ushort, int, int, double)
CV_DEF_NORM_ALL(16s, short, int, int, double)
CV_DEF_NORM_ALL(32s, int, int, double, double)
CV_DEF_NORM_ALL(32f, float, float, double, double)
CV_DEF_NORM_ALL(64f, double, double, double, double)


typedef int (*NormFunc)(const uchar*, const uchar*, uchar*, int, int);
typedef int (*NormDiffFunc)(const uchar*, const uchar*, const uchar*, uchar*, int, int);

static NormFunc getNormFunc(int normType, int depth)
{
    static NormFunc normTab[3][8] =
    {
        {
            (NormFunc)GET_OPTIMIZED(normInf_8u), (NormFunc)GET_OPTIMIZED(normInf_8s), (NormFunc)GET_OPTIMIZED(normInf_16u), (NormFunc)GET_OPTIMIZED(normInf_16s),
            (NormFunc)GET_OPTIMIZED(normInf_32s), (NormFunc)GET_OPTIMIZED(normInf_32f), (NormFunc)normInf_64f, 0
        },
        {
            (NormFunc)GET_OPTIMIZED(normL1_8u), (NormFunc)GET_OPTIMIZED(normL1_8s), (NormFunc)GET_OPTIMIZED(normL1_16u), (NormFunc)GET_OPTIMIZED(normL1_16s),
            (NormFunc)GET_OPTIMIZED(normL1_32s), (NormFunc)GET_OPTIMIZED(normL1_32f), (NormFunc)normL1_64f, 0
        },
        {
            (NormFunc)GET_OPTIMIZED(normL2_8u), (NormFunc)GET_OPTIMIZED(normL2_8s), (NormFunc)GET_OPTIMIZED(normL2_16u), (NormFunc)GET_OPTIMIZED(normL2_16s),
            (NormFunc)GET_OPTIMIZED(normL2_32s), (NormFunc)GET_OPTIMIZED(normL2_32f), (NormFunc)normL2_64f, 0
        }
    };

    return normTab[normType][depth];
}

static NormDiffFunc getNormDiffFunc(int normType, int depth)
{
    static NormDiffFunc normDiffTab[3][8] =
    {
        {
            (NormDiffFunc)GET_OPTIMIZED(normDiffInf_8u), (NormDiffFunc)normDiffInf_8s,
            (NormDiffFunc)normDiffInf_16u, (NormDiffFunc)normDiffInf_16s,
            (NormDiffFunc)normDiffInf_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffInf_32f),
            (NormDiffFunc)normDiffInf_64f, 0
        },
        {
            (NormDiffFunc)GET_OPTIMIZED(normDiffL1_8u), (NormDiffFunc)normDiffL1_8s,
            (NormDiffFunc)normDiffL1_16u, (NormDiffFunc)normDiffL1_16s,
            (NormDiffFunc)normDiffL1_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL1_32f),
            (NormDiffFunc)normDiffL1_64f, 0
        },
        {
            (NormDiffFunc)GET_OPTIMIZED(normDiffL2_8u), (NormDiffFunc)normDiffL2_8s,
            (NormDiffFunc)normDiffL2_16u, (NormDiffFunc)normDiffL2_16s,
            (NormDiffFunc)normDiffL2_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL2_32f),
            (NormDiffFunc)normDiffL2_64f, 0
        }
    };

    return normDiffTab[normType][depth];
}

#ifdef HAVE_OPENCL

static bool ocl_norm( InputArray _src, int normType, InputArray _mask, double & result )
{
    const ocl::Device & d = ocl::Device::getDefault();

#ifdef __ANDROID__
    if (d.isNVidia())
        return false;
#endif
    const int cn = _src.channels();
    if (cn > 4)
        return false;
    int type = _src.type(), depth = CV_MAT_DEPTH(type);
    bool doubleSupport = d.doubleFPConfig() > 0,
            haveMask = _mask.kind() != _InputArray::NONE;

    if ( !(normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR) ||
         (!doubleSupport && depth == CV_64F))
        return false;

    UMat src = _src.getUMat();

    if (normType == NORM_INF)
    {
        if (!ocl_minMaxIdx(_src, NULL, &result, NULL, NULL, _mask,
                           std::max(depth, CV_32S), depth != CV_8U && depth != CV_16U))
            return false;
    }
    else if (normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR)
    {
        Scalar sc;
        bool unstype = depth == CV_8U || depth == CV_16U;

        if ( !ocl_sum(haveMask ? src : src.reshape(1), sc, normType == NORM_L2 || normType == NORM_L2SQR ?
                    OCL_OP_SUM_SQR : (unstype ? OCL_OP_SUM : OCL_OP_SUM_ABS), _mask) )
            return false;

        double s = 0.0;
        for (int i = 0; i < (haveMask ? cn : 1); ++i)
            s += sc[i];

        result = normType == NORM_L1 || normType == NORM_L2SQR ? s : std::sqrt(s);
    }

    return true;
}

#endif

#ifdef HAVE_IPP
static bool ipp_norm(Mat &src, int normType, Mat &mask, double &result)
{
    CV_INSTRUMENT_REGION_IPP();

#if IPP_VERSION_X100 >= 700
    size_t total_size = src.total();
    int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;

    if( (src.dims == 2 || (src.isContinuous() && mask.isContinuous()))
        && cols > 0 && (size_t)rows*cols == total_size )
    {
        if( !mask.empty() )
        {
            IppiSize sz = { cols, rows };
            int type = src.type();

            typedef IppStatus (CV_STDCALL* ippiMaskNormFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *);
            ippiMaskNormFuncC1 ippiNorm_C1MR =
                normType == NORM_INF ?
                (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8u_C1MR :
                type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_16u_C1MR :
                type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_32f_C1MR :
                0) :
            normType == NORM_L1 ?
                (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_8u_C1MR :
                type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_16u_C1MR :
                type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_32f_C1MR :
                0) :
            normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_8u_C1MR :
                type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_16u_C1MR :
                type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_32f_C1MR :
                0) : 0;
            if( ippiNorm_C1MR )
            {
                Ipp64f norm;
                if( CV_INSTRUMENT_FUN_IPP(ippiNorm_C1MR, src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, &norm) >= 0 )
                {
                    result = (normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm);
                    return true;
                }
            }
            typedef IppStatus (CV_STDCALL* ippiMaskNormFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *);
            ippiMaskNormFuncC3 ippiNorm_C3CMR =
                normType == NORM_INF ?
                (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8u_C3CMR :
                type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_16u_C3CMR :
                type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_32f_C3CMR :
                0) :
            normType == NORM_L1 ?
                (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8u_C3CMR :
                type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_16u_C3CMR :
                type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_32f_C3CMR :
                0) :
            normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_8u_C3CMR :
                type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_16u_C3CMR :
                type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_32f_C3CMR :
                0) : 0;
            if( ippiNorm_C3CMR )
            {
                Ipp64f norm1, norm2, norm3;
                if( CV_INSTRUMENT_FUN_IPP(ippiNorm_C3CMR, src.data, (int)src.step[0], mask.data, (int)mask.step[0], sz, 1, &norm1) >= 0 &&
                    CV_INSTRUMENT_FUN_IPP(ippiNorm_C3CMR, src.data, (int)src.step[0], mask.data, (int)mask.step[0], sz, 2, &norm2) >= 0 &&
                    CV_INSTRUMENT_FUN_IPP(ippiNorm_C3CMR, src.data, (int)src.step[0], mask.data, (int)mask.step[0], sz, 3, &norm3) >= 0)
                {
                    Ipp64f norm =
                        normType == NORM_INF ? std::max(std::max(norm1, norm2), norm3) :
                        normType == NORM_L1 ? norm1 + norm2 + norm3 :
                        normType == NORM_L2 || normType == NORM_L2SQR ? std::sqrt(norm1 * norm1 + norm2 * norm2 + norm3 * norm3) :
                        0;
                    result = (normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm);
                    return true;
                }
            }
        }
        else
        {
            IppiSize sz = { cols*src.channels(), rows };
            int type = src.depth();

            typedef IppStatus (CV_STDCALL* ippiNormFuncHint)(const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint);
            typedef IppStatus (CV_STDCALL* ippiNormFuncNoHint)(const void *, int, IppiSize, Ipp64f *);
            ippiNormFuncHint ippiNormHint =
                normType == NORM_L1 ?
                (type == CV_32FC1 ? (ippiNormFuncHint)ippiNorm_L1_32f_C1R :
                0) :
                normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_32FC1 ? (ippiNormFuncHint)ippiNorm_L2_32f_C1R :
                0) : 0;
            ippiNormFuncNoHint ippiNorm =
                normType == NORM_INF ?
                (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C1R :
                type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C1R :
                type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C1R :
                type == CV_32FC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C1R :
                0) :
                normType == NORM_L1 ?
                (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C1R :
                type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C1R :
                type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C1R :
                0) :
                normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C1R :
                type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C1R :
                type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C1R :
                0) : 0;
            if( ippiNormHint || ippiNorm )
            {
                Ipp64f norm;
                IppStatus ret = ippiNormHint ? CV_INSTRUMENT_FUN_IPP(ippiNormHint, src.ptr(), (int)src.step[0], sz, &norm, ippAlgHintAccurate) :
                                CV_INSTRUMENT_FUN_IPP(ippiNorm, src.ptr(), (int)src.step[0], sz, &norm);
                if( ret >= 0 )
                {
                    result = (normType == NORM_L2SQR) ? norm * norm : norm;
                    return true;
                }
            }
        }
    }
#else
    CV_UNUSED(src); CV_UNUSED(normType); CV_UNUSED(mask); CV_UNUSED(result);
#endif
    return false;
}
#endif

} // cv::

double cv::norm( InputArray _src, int normType, InputArray _mask )
{
    CV_INSTRUMENT_REGION();

    normType &= NORM_TYPE_MASK;
    CV_Assert( normType == NORM_INF || normType == NORM_L1 ||
               normType == NORM_L2 || normType == NORM_L2SQR ||
               ((normType == NORM_HAMMING || normType == NORM_HAMMING2) && _src.type() == CV_8U) );

#if defined HAVE_OPENCL || defined HAVE_IPP
    double _result = 0;
#endif

#ifdef HAVE_OPENCL
    CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
                ocl_norm(_src, normType, _mask, _result),
                _result)
#endif

    Mat src = _src.getMat(), mask = _mask.getMat();
    CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_norm(src, normType, mask, _result), _result);

    int depth = src.depth(), cn = src.channels();
    if( src.isContinuous() && mask.empty() )
    {
        size_t len = src.total()*cn;
        if( len == (size_t)(int)len )
        {
            if( depth == CV_32F )
            {
                const float* data = src.ptr<float>();

                if( normType == NORM_L2 )
                {
                    double result = 0;
                    GET_OPTIMIZED(normL2_32f)(data, 0, &result, (int)len, 1);
                    return std::sqrt(result);
                }
                if( normType == NORM_L2SQR )
                {
                    double result = 0;
                    GET_OPTIMIZED(normL2_32f)(data, 0, &result, (int)len, 1);
                    return result;
                }
                if( normType == NORM_L1 )
                {
                    double result = 0;
                    GET_OPTIMIZED(normL1_32f)(data, 0, &result, (int)len, 1);
                    return result;
                }
                if( normType == NORM_INF )
                {
                    float result = 0;
                    GET_OPTIMIZED(normInf_32f)(data, 0, &result, (int)len, 1);
                    return result;
                }
            }
            if( depth == CV_8U )
            {
                const uchar* data = src.ptr<uchar>();

                if( normType == NORM_HAMMING )
                {
                    return hal::normHamming(data, (int)len);
                }

                if( normType == NORM_HAMMING2 )
                {
                    return hal::normHamming(data, (int)len, 2);
                }
            }
        }
    }

    CV_Assert( mask.empty() || mask.type() == CV_8U );

    if( normType == NORM_HAMMING || normType == NORM_HAMMING2 )
    {
        if( !mask.empty() )
        {
            Mat temp;
            bitwise_and(src, mask, temp);
            return norm(temp, normType);
        }
        int cellSize = normType == NORM_HAMMING ? 1 : 2;

        const Mat* arrays[] = {&src, 0};
        uchar* ptrs[1] = {};
        NAryMatIterator it(arrays, ptrs);
        int total = (int)it.size;
        int result = 0;

        for( size_t i = 0; i < it.nplanes; i++, ++it )
        {
            result += hal::normHamming(ptrs[0], total, cellSize);
        }

        return result;
    }

    NormFunc func = getNormFunc(normType >> 1, depth);
    CV_Assert( func != 0 );

    const Mat* arrays[] = {&src, &mask, 0};
    uchar* ptrs[2] = {};
    union
    {
        double d;
        int i;
        float f;
    }
    result;
    result.d = 0;
    NAryMatIterator it(arrays, ptrs);
    int j, total = (int)it.size, blockSize = total, intSumBlockSize = 0, count = 0;
    bool blockSum = (normType == NORM_L1 && depth <= CV_16S) ||
            ((normType == NORM_L2 || normType == NORM_L2SQR) && depth <= CV_8S);
    int isum = 0;
    int *ibuf = &result.i;
    size_t esz = 0;

    if( blockSum )
    {
        intSumBlockSize = (normType == NORM_L1 && depth <= CV_8S ? (1 << 23) : (1 << 15))/cn;
        blockSize = std::min(blockSize, intSumBlockSize);
        ibuf = &isum;
        esz = src.elemSize();
    }

    for( size_t i = 0; i < it.nplanes; i++, ++it )
    {
        for( j = 0; j < total; j += blockSize )
        {
            int bsz = std::min(total - j, blockSize);
            func( ptrs[0], ptrs[1], (uchar*)ibuf, bsz, cn );
            count += bsz;
            if( blockSum && (count + blockSize >= intSumBlockSize || (i+1 >= it.nplanes && j+bsz >= total)) )
            {
                result.d += isum;
                isum = 0;
                count = 0;
            }
            ptrs[0] += bsz*esz;
            if( ptrs[1] )
                ptrs[1] += bsz;
        }
    }

    if( normType == NORM_INF )
    {
        if( depth == CV_64F )
            ;
        else if( depth == CV_32F )
            result.d = result.f;
        else
            result.d = result.i;
    }
    else if( normType == NORM_L2 )
        result.d = std::sqrt(result.d);

    return result.d;
}

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

#ifdef HAVE_OPENCL

namespace cv {

static bool ocl_norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask, double & result )
{
#ifdef __ANDROID__
    if (ocl::Device::getDefault().isNVidia())
        return false;
#endif

    Scalar sc1, sc2;
    int cn = _src1.channels();
    if (cn > 4)
        return false;
    int type = _src1.type(), depth = CV_MAT_DEPTH(type);
    bool relative = (normType & NORM_RELATIVE) != 0;
    normType &= ~NORM_RELATIVE;
    bool normsum = normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR;

#ifdef __APPLE__
    if(normType == NORM_L1 && type == CV_16UC3 && !_mask.empty())
        return false;
#endif

    if (normsum)
    {
        if (!ocl_sum(_src1, sc1, normType == NORM_L2 || normType == NORM_L2SQR ?
                     OCL_OP_SUM_SQR : OCL_OP_SUM, _mask, _src2, relative, sc2))
            return false;
    }
    else
    {
        if (!ocl_minMaxIdx(_src1, NULL, &sc1[0], NULL, NULL, _mask, std::max(CV_32S, depth),
                           false, _src2, relative ? &sc2[0] : NULL))
            return false;
        cn = 1;
    }

    double s2 = 0;
    for (int i = 0; i < cn; ++i)
    {
        result += sc1[i];
        if (relative)
            s2 += sc2[i];
    }

    if (normType == NORM_L2)
    {
        result = std::sqrt(result);
        if (relative)
            s2 = std::sqrt(s2);
    }

    if (relative)
        result /= (s2 + DBL_EPSILON);

    return true;
}

}

#endif

#ifdef HAVE_IPP
namespace cv
{
static bool ipp_norm(InputArray _src1, InputArray _src2, int normType, InputArray _mask, double &result)
{
    CV_INSTRUMENT_REGION_IPP();

#if IPP_VERSION_X100 >= 700
    Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat();

    if( normType & CV_RELATIVE )
    {
        normType &= NORM_TYPE_MASK;

        size_t total_size = src1.total();
        int rows = src1.size[0], cols = rows ? (int)(total_size/rows) : 0;
        if( (src1.dims == 2 || (src1.isContinuous() && src2.isContinuous() && mask.isContinuous()))
            && cols > 0 && (size_t)rows*cols == total_size )
        {
            if( !mask.empty() )
            {
                IppiSize sz = { cols, rows };
                int type = src1.type();

                typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *);
                ippiMaskNormDiffFuncC1 ippiNormRel_C1MR =
                    normType == NORM_INF ?
                    (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_Inf_8u_C1MR :
                    type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_Inf_16u_C1MR :
                    type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_Inf_32f_C1MR :
                    0) :
                    normType == NORM_L1 ?
                    (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_L1_8u_C1MR :
                    type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_L1_16u_C1MR :
                    type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_L1_32f_C1MR :
                    0) :
                    normType == NORM_L2 || normType == NORM_L2SQR ?
                    (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_L2_8u_C1MR :
                    type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_L2_16u_C1MR :
                    type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormRel_L2_32f_C1MR :
                    0) : 0;
                if( ippiNormRel_C1MR )
                {
                    Ipp64f norm;
                    if( CV_INSTRUMENT_FUN_IPP(ippiNormRel_C1MR, src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], mask.ptr(), (int)mask.step[0], sz, &norm) >= 0 )
                    {
                        result = (normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm);
                        return true;
                    }
                }
            }
            else
            {
                IppiSize sz = { cols*src1.channels(), rows };
                int type = src1.depth();

                typedef IppStatus (CV_STDCALL* ippiNormRelFuncHint)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint);
                typedef IppStatus (CV_STDCALL* ippiNormRelFuncNoHint)(const void *, int, const void *, int, IppiSize, Ipp64f *);
                ippiNormRelFuncHint ippiNormRelHint =
                    normType == NORM_L1 ?
                    (type == CV_32F ? (ippiNormRelFuncHint)ippiNormRel_L1_32f_C1R :
                    0) :
                    normType == NORM_L2 || normType == NORM_L2SQR ?
                    (type == CV_32F ? (ippiNormRelFuncHint)ippiNormRel_L2_32f_C1R :
                    0) : 0;
                ippiNormRelFuncNoHint ippiNormRel =
                    normType == NORM_INF ?
                    (type == CV_8U ? (ippiNormRelFuncNoHint)ippiNormRel_Inf_8u_C1R :
                    type == CV_16U ? (ippiNormRelFuncNoHint)ippiNormRel_Inf_16u_C1R :
                    type == CV_16S ? (ippiNormRelFuncNoHint)ippiNormRel_Inf_16s_C1R :
                    type == CV_32F ? (ippiNormRelFuncNoHint)ippiNormRel_Inf_32f_C1R :
                    0) :
                    normType == NORM_L1 ?
                    (type == CV_8U ? (ippiNormRelFuncNoHint)ippiNormRel_L1_8u_C1R :
                    type == CV_16U ? (ippiNormRelFuncNoHint)ippiNormRel_L1_16u_C1R :
                    type == CV_16S ? (ippiNormRelFuncNoHint)ippiNormRel_L1_16s_C1R :
                    0) :
                    normType == NORM_L2 || normType == NORM_L2SQR ?
                    (type == CV_8U ? (ippiNormRelFuncNoHint)ippiNormRel_L2_8u_C1R :
                    type == CV_16U ? (ippiNormRelFuncNoHint)ippiNormRel_L2_16u_C1R :
                    type == CV_16S ? (ippiNormRelFuncNoHint)ippiNormRel_L2_16s_C1R :
                    0) : 0;
                if( ippiNormRelHint || ippiNormRel )
                {
                    Ipp64f norm;
                    IppStatus ret = ippiNormRelHint ? CV_INSTRUMENT_FUN_IPP(ippiNormRelHint, src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], sz, &norm, ippAlgHintAccurate) :
                                    CV_INSTRUMENT_FUN_IPP(ippiNormRel, src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], sz, &norm);
                    if( ret >= 0 )
                    {
                        result = (normType == NORM_L2SQR) ? norm * norm : norm;
                        return true;
                    }
                }
            }
        }
        return false;
    }

    normType &= NORM_TYPE_MASK;

    size_t total_size = src1.total();
    int rows = src1.size[0], cols = rows ? (int)(total_size/rows) : 0;
    if( (src1.dims == 2 || (src1.isContinuous() && src2.isContinuous() && mask.isContinuous()))
        && cols > 0 && (size_t)rows*cols == total_size )
    {
        if( !mask.empty() )
        {
            IppiSize sz = { cols, rows };
            int type = src1.type();

            typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *);
            ippiMaskNormDiffFuncC1 ippiNormDiff_C1MR =
                normType == NORM_INF ?
                (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_8u_C1MR :
                type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_16u_C1MR :
                type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_32f_C1MR :
                0) :
                normType == NORM_L1 ?
                (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_8u_C1MR :
                type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_16u_C1MR :
                type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_32f_C1MR :
                0) :
                normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_8u_C1MR :
                type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_16u_C1MR :
                type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_32f_C1MR :
                0) : 0;
            if( ippiNormDiff_C1MR )
            {
                Ipp64f norm;
                if( CV_INSTRUMENT_FUN_IPP(ippiNormDiff_C1MR, src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], mask.ptr(), (int)mask.step[0], sz, &norm) >= 0 )
                {
                    result = (normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm);
                    return true;
                }
            }
            typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC3)(const void *, int, const void *, int, const void *, int, IppiSize, int, Ipp64f *);
            ippiMaskNormDiffFuncC3 ippiNormDiff_C3CMR =
                normType == NORM_INF ?
                (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8u_C3CMR :
                type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_16u_C3CMR :
                type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_32f_C3CMR :
                0) :
                normType == NORM_L1 ?
                (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8u_C3CMR :
                type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_16u_C3CMR :
                type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_32f_C3CMR :
                0) :
                normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_8u_C3CMR :
                type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_16u_C3CMR :
                type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_32f_C3CMR :
                0) : 0;
            if (cv::ipp::getIppTopFeatures() & (
#if IPP_VERSION_X100 >= 201700
                    ippCPUID_AVX512F |
#endif
                    ippCPUID_AVX2)
            ) // IPP_DISABLE_NORM_16UC3_mask_small (#11399)
            {
                if (normType == NORM_L1 && type == CV_16UC3 && sz.width < 16)
                    return false;
            }
            if( ippiNormDiff_C3CMR )
            {
                Ipp64f norm1, norm2, norm3;
                if( CV_INSTRUMENT_FUN_IPP(ippiNormDiff_C3CMR, src1.data, (int)src1.step[0], src2.data, (int)src2.step[0], mask.data, (int)mask.step[0], sz, 1, &norm1) >= 0 &&
                    CV_INSTRUMENT_FUN_IPP(ippiNormDiff_C3CMR, src1.data, (int)src1.step[0], src2.data, (int)src2.step[0], mask.data, (int)mask.step[0], sz, 2, &norm2) >= 0 &&
                    CV_INSTRUMENT_FUN_IPP(ippiNormDiff_C3CMR, src1.data, (int)src1.step[0], src2.data, (int)src2.step[0], mask.data, (int)mask.step[0], sz, 3, &norm3) >= 0)
                {
                    Ipp64f norm =
                        normType == NORM_INF ? std::max(std::max(norm1, norm2), norm3) :
                        normType == NORM_L1 ? norm1 + norm2 + norm3 :
                        normType == NORM_L2 || normType == NORM_L2SQR ? std::sqrt(norm1 * norm1 + norm2 * norm2 + norm3 * norm3) :
                        0;
                    result = (normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm);
                    return true;
                }
            }
        }
        else
        {
            IppiSize sz = { cols*src1.channels(), rows };
            int type = src1.depth();

            typedef IppStatus (CV_STDCALL* ippiNormDiffFuncHint)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint);
            typedef IppStatus (CV_STDCALL* ippiNormDiffFuncNoHint)(const void *, int, const void *, int, IppiSize, Ipp64f *);
            ippiNormDiffFuncHint ippiNormDiffHint =
                normType == NORM_L1 ?
                (type == CV_32F ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C1R :
                0) :
                normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_32F ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C1R :
                0) : 0;
            ippiNormDiffFuncNoHint ippiNormDiff =
                normType == NORM_INF ?
                (type == CV_8U ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C1R :
                type == CV_16U ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C1R :
                type == CV_16S ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C1R :
                type == CV_32F ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C1R :
                0) :
                normType == NORM_L1 ?
                (type == CV_8U ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C1R :
                type == CV_16U ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C1R :
                type == CV_16S ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C1R :
                0) :
                normType == NORM_L2 || normType == NORM_L2SQR ?
                (type == CV_8U ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C1R :
                type == CV_16U ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C1R :
                type == CV_16S ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C1R :
                0) : 0;
            if( ippiNormDiffHint || ippiNormDiff )
            {
                Ipp64f norm;
                IppStatus ret = ippiNormDiffHint ? CV_INSTRUMENT_FUN_IPP(ippiNormDiffHint, src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], sz, &norm, ippAlgHintAccurate) :
                                CV_INSTRUMENT_FUN_IPP(ippiNormDiff, src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], sz, &norm);
                if( ret >= 0 )
                {
                    result = (normType == NORM_L2SQR) ? norm * norm : norm;
                    return true;
                }
            }
        }
    }
#else
    CV_UNUSED(_src1); CV_UNUSED(_src2); CV_UNUSED(normType); CV_UNUSED(_mask); CV_UNUSED(result);
#endif
    return false;
}
}
#endif


double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask )
{
    CV_INSTRUMENT_REGION();

    CV_Assert( _src1.sameSize(_src2) && _src1.type() == _src2.type() );

#if defined HAVE_OPENCL || defined HAVE_IPP
    double _result = 0;
#endif

#ifdef HAVE_OPENCL
    CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src1.isUMat()),
                ocl_norm(_src1, _src2, normType, _mask, _result),
                _result)
#endif

    CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_norm(_src1, _src2, normType, _mask, _result), _result);

    if( normType & CV_RELATIVE )
    {
        return norm(_src1, _src2, normType & ~CV_RELATIVE, _mask)/(norm(_src2, normType, _mask) + DBL_EPSILON);
    }

    Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat();
    int depth = src1.depth(), cn = src1.channels();

    normType &= 7;
    CV_Assert( normType == NORM_INF || normType == NORM_L1 ||
               normType == NORM_L2 || normType == NORM_L2SQR ||
              ((normType == NORM_HAMMING || normType == NORM_HAMMING2) && src1.type() == CV_8U) );

    if( src1.isContinuous() && src2.isContinuous() && mask.empty() )
    {
        size_t len = src1.total()*src1.channels();
        if( len == (size_t)(int)len )
        {
            if( src1.depth() == CV_32F )
            {
                const float* data1 = src1.ptr<float>();
                const float* data2 = src2.ptr<float>();

                if( normType == NORM_L2 )
                {
                    double result = 0;
                    GET_OPTIMIZED(normDiffL2_32f)(data1, data2, 0, &result, (int)len, 1);
                    return std::sqrt(result);
                }
                if( normType == NORM_L2SQR )
                {
                    double result = 0;
                    GET_OPTIMIZED(normDiffL2_32f)(data1, data2, 0, &result, (int)len, 1);
                    return result;
                }
                if( normType == NORM_L1 )
                {
                    double result = 0;
                    GET_OPTIMIZED(normDiffL1_32f)(data1, data2, 0, &result, (int)len, 1);
                    return result;
                }
                if( normType == NORM_INF )
                {
                    float result = 0;
                    GET_OPTIMIZED(normDiffInf_32f)(data1, data2, 0, &result, (int)len, 1);
                    return result;
                }
            }
        }
    }

    CV_Assert( mask.empty() || mask.type() == CV_8U );

    if( normType == NORM_HAMMING || normType == NORM_HAMMING2 )
    {
        if( !mask.empty() )
        {
            Mat temp;
            bitwise_xor(src1, src2, temp);
            bitwise_and(temp, mask, temp);
            return norm(temp, normType);
        }
        int cellSize = normType == NORM_HAMMING ? 1 : 2;

        const Mat* arrays[] = {&src1, &src2, 0};
        uchar* ptrs[2] = {};
        NAryMatIterator it(arrays, ptrs);
        int total = (int)it.size;
        int result = 0;

        for( size_t i = 0; i < it.nplanes; i++, ++it )
        {
            result += hal::normHamming(ptrs[0], ptrs[1], total, cellSize);
        }

        return result;
    }

    NormDiffFunc func = getNormDiffFunc(normType >> 1, depth);
    CV_Assert( func != 0 );

    const Mat* arrays[] = {&src1, &src2, &mask, 0};
    uchar* ptrs[3] = {};
    union
    {
        double d;
        float f;
        int i;
        unsigned u;
    }
    result;
    result.d = 0;
    NAryMatIterator it(arrays, ptrs);
    int j, total = (int)it.size, blockSize = total, intSumBlockSize = 0, count = 0;
    bool blockSum = (normType == NORM_L1 && depth <= CV_16S) ||
            ((normType == NORM_L2 || normType == NORM_L2SQR) && depth <= CV_8S);
    unsigned isum = 0;
    unsigned *ibuf = &result.u;
    size_t esz = 0;

    if( blockSum )
    {
        intSumBlockSize = normType == NORM_L1 && depth <= CV_8S ? (1 << 23) : (1 << 15);
        blockSize = std::min(blockSize, intSumBlockSize);
        ibuf = &isum;
        esz = src1.elemSize();
    }

    for( size_t i = 0; i < it.nplanes; i++, ++it )
    {
        for( j = 0; j < total; j += blockSize )
        {
            int bsz = std::min(total - j, blockSize);
            func( ptrs[0], ptrs[1], ptrs[2], (uchar*)ibuf, bsz, cn );
            count += bsz;
            if( blockSum && (count + blockSize >= intSumBlockSize || (i+1 >= it.nplanes && j+bsz >= total)) )
            {
                result.d += isum;
                isum = 0;
                count = 0;
            }
            ptrs[0] += bsz*esz;
            ptrs[1] += bsz*esz;
            if( ptrs[2] )
                ptrs[2] += bsz;
        }
    }

    if( normType == NORM_INF )
    {
        if( depth == CV_64F )
            ;
        else if( depth == CV_32F )
            result.d = result.f;
        else
            result.d = result.u;
    }
    else if( normType == NORM_L2 )
        result.d = std::sqrt(result.d);

    return result.d;
}

cv::Hamming::ResultType cv::Hamming::operator()( const unsigned char* a, const unsigned char* b, int size ) const
{
    return cv::hal::normHamming(a, b, size);
}

double cv::PSNR(InputArray _src1, InputArray _src2)
{
    CV_INSTRUMENT_REGION();

    //Input arrays must have depth CV_8U
    CV_Assert( _src1.depth() == CV_8U && _src2.depth() == CV_8U );

    double diff = std::sqrt(norm(_src1, _src2, NORM_L2SQR)/(_src1.total()*_src1.channels()));
    return 20*log10(255./(diff+DBL_EPSILON));
}
",16350,True,2709.569981064102,median
"// Copyright 2019 The MACE Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the ""License"");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#include ""mace/ops/arm/fp32/gemm.h""

#include <arm_neon.h>
#include <algorithm>
#include <utility>

#include ""mace/port/env.h""

namespace mace {
namespace ops {
namespace arm {
namespace fp32 {

enum { kNoCache, kCacheLhs, kCacheRhs };

MaceStatus Gemm::Compute(const OpContext *context,
                         const Tensor *lhs,
                         const Tensor *rhs,
                         const index_t batch,
                         const index_t rows,
                         const index_t cols,
                         const index_t depth,
                         const MatrixMajor lhs_major,
                         const MatrixMajor rhs_major,
                         const MatrixMajor output_major,
                         const bool lhs_batched,
                         const bool rhs_batched,
                         Tensor *output) {
  MACE_CHECK(output->size() == batch * rows * cols,
             ""Need resize output tensor before call gemm."");
  Tensor::MappingGuard lhs_guard(lhs);
  Tensor::MappingGuard rhs_guard(rhs);
  Tensor::MappingGuard output_guard(output);
  const float *lhs_data = lhs->data<float>();
  const float *rhs_data = rhs->data<float>();
  float *output_data = output->mutable_data<float>();

#ifdef __aarch64__
  const index_t row_block_size = 8;
#else
  const index_t row_block_size = 4;
#endif
  const index_t col_block_size = 8;
  const index_t depth_block_size = 4;
  const index_t row_block_count = RoundUpDiv(rows, row_block_size);
  const index_t col_block_count = RoundUpDiv(cols, col_block_size);
  const index_t rows_padded = RoundUp(rows, row_block_size);
  const index_t cols_padded = RoundUp(cols, col_block_size);
  const index_t depth_padded = RoundUp(depth, depth_block_size);

  ScratchBuffer *scratch = context->device()->scratch_buffer();

  index_t packed_lhs_size =
      PadAlignSize(sizeof(float) * rows_padded * depth_padded);
  index_t packed_rhs_size =
      PadAlignSize(sizeof(float) * depth_padded * cols_padded);
  index_t packed_output_size =
      PadAlignSize(sizeof(float) * rows_padded * cols_padded);
  // resize to the total size of lhs & rhs & output anyway,
  // in case we do not cache const tensor for saving memory
  MACE_RETURN_IF_ERROR(scratch->GrowSize(
      packed_lhs_size + packed_rhs_size + packed_output_size));
  float *packed_lhs_data =
      scratch->Scratch(packed_lhs_size).mutable_data<float>();
  float *packed_rhs_data =
      scratch->Scratch(packed_rhs_size).mutable_data<float>();
  float *packed_output_data =
      scratch->Scratch(packed_output_size).mutable_data<float>();

  int cache_side = kNoCache;
  if (cached_ == kCacheLhs) {
    packed_lhs_data = pack_cache_.mutable_data<float>();
  } else if (cached_ == kCacheRhs) {
    packed_rhs_data = pack_cache_.mutable_data<float>();
  } else if (should_cache_pack_) {
    if (lhs->is_weight() && (!lhs_batched || batch == 1)) {
      cache_side = kCacheLhs;
      pack_cache_.Resize(packed_lhs_size);
      packed_lhs_data = pack_cache_.mutable_data<float>();
    } else if (rhs->is_weight() && (!rhs_batched || batch == 1)) {
      cache_side = kCacheRhs;
      pack_cache_.Resize(packed_rhs_size);
      packed_rhs_data = pack_cache_.mutable_data<float>();
    }
  }

  utils::ThreadPool
      &thread_pool = context->device()->cpu_runtime()->thread_pool();

  for (index_t b = 0; b < batch; ++b) {
    MatrixMap<const float>
        lhs_matrix
        (lhs_data + static_cast<index_t>(lhs_batched) * b * rows * depth,
         lhs_major,
         rows,
         depth);
    MatrixMap<const float>
        rhs_matrix
        (rhs_data + static_cast<index_t>(rhs_batched) * b * depth * cols,
         rhs_major,
         depth,
         cols);
    MatrixMap<float> output_matrix
        (output_data + b * rows * cols, output_major, rows, cols);

    // pack lhs
    if (cached_ != kCacheLhs) {
      thread_pool.Compute1D([=, &lhs_matrix](index_t start,
                                             index_t end,
                                             index_t step) {
        for (index_t row_block_idx = start; row_block_idx < end;
             row_block_idx += step) {
          const index_t start_row = row_block_idx * row_block_size;
          const index_t
              row_block_len = std::min(row_block_size, rows - start_row);
          float *packed_lhs_data_block =
              packed_lhs_data + row_block_idx * row_block_size * depth_padded;
          PackLhs(lhs_matrix.block(start_row, 0, row_block_len, depth),
                  packed_lhs_data_block);
        }
      }, 0, row_block_count, 1);

      if (cache_side == kCacheLhs) {
        cached_ = kCacheLhs;
        if (lhs->UnderlyingBuffer()->OnHost()) {
          AdviseFree(reinterpret_cast<void *>(const_cast<float *>(lhs->data<
                         float>())),
                     lhs->raw_size());
        }
      }
    }

    // pack rhs
    if (cached_ != kCacheRhs) {
      thread_pool.Compute1D([=, &rhs_matrix](index_t start,
                                             index_t end,
                                             index_t step) {
        for (index_t col_block_idx = start; col_block_idx < end;
             col_block_idx += step) {
          const index_t start_col = col_block_idx * col_block_size;
          const index_t
              col_block_len = std::min(col_block_size, cols - start_col);
          float *packed_rhs_data_block =
              packed_rhs_data + col_block_idx * col_block_size * depth_padded;
          PackRhs(rhs_matrix.block(0, start_col, depth, col_block_len),
                  packed_rhs_data_block);
        }
      }, 0, col_block_count, 1);

      if (cache_side == kCacheRhs) {
        cached_ = kCacheRhs;
        if (rhs->UnderlyingBuffer()->OnHost()) {
          AdviseFree(reinterpret_cast<void *>(const_cast<float *>(rhs->data<
                         float>())),
                     rhs->raw_size());
        }
      }
    }

    // multiply lhs and rhs
    thread_pool.Compute1D([=, &output_matrix](index_t start,
                                              index_t end,
                                              index_t step) {
      for (index_t row_block_idx = start; row_block_idx < end;
           row_block_idx += step) {
        const index_t start_row = row_block_idx * row_block_size;
        const index_t
            row_block_len = std::min(row_block_size, rows - start_row);
        const float *packed_lhs_data_block =
            packed_lhs_data + row_block_idx * row_block_size * depth_padded;

        for (index_t col_block_idx = 0; col_block_idx < col_block_count;
             ++col_block_idx) {
          const index_t start_col = col_block_idx * col_block_size;
          const index_t
              col_block_len = std::min(col_block_size, cols - start_col);
          const float *packed_rhs_data_block =
              packed_rhs_data + col_block_idx * col_block_size * depth_padded;
          float *packed_output_data_block =
              packed_output_data + row_block_idx * row_block_size * cols_padded
                  + col_block_idx * col_block_size;
          ComputeBlock(packed_lhs_data_block,
                       packed_rhs_data_block,
                       depth_padded,
                       packed_output_data_block);
          MatrixMap<float> output_block = output_matrix.block(start_row,
                                                              start_col,
                                                              row_block_len,
                                                              col_block_len);
          UnpackOutput(packed_output_data_block, &output_block);
        }  // col_block_idx
      }  // row_block_idx
    }, 0, row_block_count, 1);
  }  // b

  return MaceStatus::MACE_SUCCESS;
}

void Gemm::ComputeBlock(const float *packed_lhs_data,
                        const float *packed_rhs_data,
                        const index_t depth_padded,
                        float *packed_output_data) {
  /* Ref:
  for (index_t r = 0; r < block_size; ++r) {
    for (index_t c = 0; c < block_size; ++c) {
      float sum = 0;
      for (index_t d = 0; d < depth; ++d) {
        // (r, d) * (d, c)
        sum += packed_lhs_data[d * r_block_size + r]
            * packed_rhs_data[d * c_block_size + c];
      }
      packed_output_data[r * c_block_size + c] = sum;
    }
  }
  */
  const float *lhs_ptr = packed_lhs_data;
  const float *rhs_ptr = packed_rhs_data;

  const index_t depth_block_count = depth_padded / 4;

#ifdef __aarch64__
  // Register layout: (8x4) x (4,8)
  //
  //                               +--------+--------+
  //                               | v8 ... | v9 ... |
  //                       Rhs     +--------+--------+
  //                               | v10... | v11... |
  //                               +--------+--------+
  //                               | v12... | v13... |
  //                               +--------+--------+
  //                               | v14... | v15... |
  //                               +--------+--------+
  //
  //          Lhs
  //
  //  +----+----+----+----+  -  -  +--------+--------+
  //  | v0 | v2 | v4 | v6 |        | v16... | v17... |
  //  | .  |    |    |    |        | v18... | v19... |
  //  | .  |    |    |    |        | v20... | v21... |
  //  | .  |    |    |    |        | v22... | v23... |
  //  +----+----|----+----+        +--------+--------+
  //  | v1 | v3 | v5 | v7 |        | v24... | v25... |
  //  | .  |    |    |    |        | v26... | v27... |
  //  | .  |    |    |    |        | v28... | v29... |
  //  | .  |    |    |    |        | v30... | v31... |
  //  +----+----|----+----+        +--------+--------+
  //
  //                                    Accumulator
  //

  if (depth_block_count > 0) {
    index_t r_depth_block_count = depth_block_count;
    // just make compiler happy
    MACE_UNUSED(r_depth_block_count);

    asm volatile(
        ""dup v16.4s, wzr \\n""
        ""dup v17.4s, wzr \\n""
        ""dup v18.4s, wzr \\n""
        ""dup v19.4s, wzr \\n""
        ""dup v20.4s, wzr \\n""
        ""dup v21.4s, wzr \\n""
        ""dup v22.4s, wzr \\n""
        ""dup v23.4s, wzr \\n""
        ""dup v24.4s, wzr \\n""
        ""dup v25.4s, wzr \\n""
        ""dup v26.4s, wzr \\n""
        ""dup v27.4s, wzr \\n""
        ""dup v28.4s, wzr \\n""
        ""dup v29.4s, wzr \\n""
        ""dup v30.4s, wzr \\n""
        ""dup v31.4s, wzr \\n""

        // prelogue
        ""ld1 {v0.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v1.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v2.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v3.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v4.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v5.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v6.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v7.4s}, [%[lhs_ptr]], #16 \\n""

        ""ld1 {v8.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v9.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v10.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v11.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v12.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v13.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v14.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v15.4s}, [%[rhs_ptr]], #16 \\n""

        ""subs %[r_depth_block_count], %[r_depth_block_count], #1 \\n""
        ""beq 1f\\n""

        ""0: \\n""
        ""fmla v16.4s, v8.4s, v0.s[0] \\n""
        ""fmla v17.4s, v9.4s, v0.s[0] \\n""
        ""fmla v18.4s, v8.4s, v0.s[1] \\n""
        ""fmla v19.4s, v9.4s, v0.s[1] \\n""
        ""fmla v20.4s, v8.4s, v0.s[2] \\n""
        ""fmla v21.4s, v9.4s, v0.s[2] \\n""
        ""fmla v22.4s, v8.4s, v0.s[3] \\n""
        ""fmla v23.4s, v9.4s, v0.s[3] \\n""

        ""ld1 {v0.4s}, [%[lhs_ptr]], #16 \\n""

        ""fmla v24.4s, v8.4s, v1.s[0] \\n""
        ""fmla v25.4s, v9.4s, v1.s[0] \\n""
        ""fmla v26.4s, v8.4s, v1.s[1] \\n""
        ""fmla v27.4s, v9.4s, v1.s[1] \\n""
        ""fmla v28.4s, v8.4s, v1.s[2] \\n""
        ""fmla v29.4s, v9.4s, v1.s[2] \\n""
        ""fmla v30.4s, v8.4s, v1.s[3] \\n""
        ""fmla v31.4s, v9.4s, v1.s[3] \\n""

        ""ld1 {v1.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v8.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v9.4s}, [%[rhs_ptr]], #16 \\n""

        ""fmla v16.4s, v10.4s, v2.s[0] \\n""
        ""fmla v17.4s, v11.4s, v2.s[0] \\n""
        ""fmla v18.4s, v10.4s, v2.s[1] \\n""
        ""fmla v19.4s, v11.4s, v2.s[1] \\n""
        ""fmla v20.4s, v10.4s, v2.s[2] \\n""
        ""fmla v21.4s, v11.4s, v2.s[2] \\n""
        ""fmla v22.4s, v10.4s, v2.s[3] \\n""
        ""fmla v23.4s, v11.4s, v2.s[3] \\n""

        ""ld1 {v2.4s}, [%[lhs_ptr]], #16 \\n""

        ""fmla v24.4s, v10.4s, v3.s[0] \\n""
        ""fmla v25.4s, v11.4s, v3.s[0] \\n""
        ""fmla v26.4s, v10.4s, v3.s[1] \\n""
        ""fmla v27.4s, v11.4s, v3.s[1] \\n""
        ""fmla v28.4s, v10.4s, v3.s[2] \\n""
        ""fmla v29.4s, v11.4s, v3.s[2] \\n""
        ""fmla v30.4s, v10.4s, v3.s[3] \\n""
        ""fmla v31.4s, v11.4s, v3.s[3] \\n""

        ""ld1 {v3.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v10.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v11.4s}, [%[rhs_ptr]], #16 \\n""

        ""fmla v16.4s, v12.4s, v4.s[0] \\n""
        ""fmla v17.4s, v13.4s, v4.s[0] \\n""
        ""fmla v18.4s, v12.4s, v4.s[1] \\n""
        ""fmla v19.4s, v13.4s, v4.s[1] \\n""
        ""fmla v20.4s, v12.4s, v4.s[2] \\n""
        ""fmla v21.4s, v13.4s, v4.s[2] \\n""
        ""fmla v22.4s, v12.4s, v4.s[3] \\n""
        ""fmla v23.4s, v13.4s, v4.s[3] \\n""

        ""ld1 {v4.4s}, [%[lhs_ptr]], #16 \\n""

        ""fmla v24.4s, v12.4s, v5.s[0] \\n""
        ""fmla v25.4s, v13.4s, v5.s[0] \\n""
        ""fmla v26.4s, v12.4s, v5.s[1] \\n""
        ""fmla v27.4s, v13.4s, v5.s[1] \\n""
        ""fmla v28.4s, v12.4s, v5.s[2] \\n""
        ""fmla v29.4s, v13.4s, v5.s[2] \\n""
        ""fmla v30.4s, v12.4s, v5.s[3] \\n""
        ""fmla v31.4s, v13.4s, v5.s[3] \\n""

        ""ld1 {v5.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v12.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v13.4s}, [%[rhs_ptr]], #16 \\n""

        ""fmla v16.4s, v14.4s, v6.s[0] \\n""
        ""fmla v17.4s, v15.4s, v6.s[0] \\n""
        ""fmla v18.4s, v14.4s, v6.s[1] \\n""
        ""fmla v19.4s, v15.4s, v6.s[1] \\n""
        ""fmla v20.4s, v14.4s, v6.s[2] \\n""
        ""fmla v21.4s, v15.4s, v6.s[2] \\n""
        ""fmla v22.4s, v14.4s, v6.s[3] \\n""
        ""fmla v23.4s, v15.4s, v6.s[3] \\n""

        ""ld1 {v6.4s}, [%[lhs_ptr]], #16 \\n""

        ""subs %[r_depth_block_count], %[r_depth_block_count], #1 \\n""

        ""fmla v24.4s, v14.4s, v7.s[0] \\n""
        ""fmla v25.4s, v15.4s, v7.s[0] \\n""
        ""fmla v26.4s, v14.4s, v7.s[1] \\n""
        ""fmla v27.4s, v15.4s, v7.s[1] \\n""
        ""fmla v28.4s, v14.4s, v7.s[2] \\n""
        ""fmla v29.4s, v15.4s, v7.s[2] \\n""
        ""fmla v30.4s, v14.4s, v7.s[3] \\n""
        ""fmla v31.4s, v15.4s, v7.s[3] \\n""

        ""ld1 {v7.4s}, [%[lhs_ptr]], #16 \\n""
        ""ld1 {v14.4s}, [%[rhs_ptr]], #16 \\n""
        ""ld1 {v15.4s}, [%[rhs_ptr]], #16 \\n""

        ""bne 0b \\n""

        // prologue
        ""1:\\n""
        ""fmla v16.4s, v8.4s, v0.s[0] \\n""
        ""fmla v17.4s, v9.4s, v0.s[0] \\n""
        ""fmla v18.4s, v8.4s, v0.s[1] \\n""
        ""fmla v19.4s, v9.4s, v0.s[1] \\n""
        ""fmla v20.4s, v8.4s, v0.s[2] \\n""
        ""fmla v21.4s, v9.4s, v0.s[2] \\n""
        ""fmla v22.4s, v8.4s, v0.s[3] \\n""
        ""fmla v23.4s, v9.4s, v0.s[3] \\n""

        ""fmla v24.4s, v8.4s, v1.s[0] \\n""
        ""fmla v25.4s, v9.4s, v1.s[0] \\n""
        ""fmla v26.4s, v8.4s, v1.s[1] \\n""
        ""fmla v27.4s, v9.4s, v1.s[1] \\n""
        ""fmla v28.4s, v8.4s, v1.s[2] \\n""
        ""fmla v29.4s, v9.4s, v1.s[2] \\n""
        ""fmla v30.4s, v8.4s, v1.s[3] \\n""
        ""fmla v31.4s, v9.4s, v1.s[3] \\n""

        ""fmla v16.4s, v10.4s, v2.s[0] \\n""
        ""fmla v17.4s, v11.4s, v2.s[0] \\n""
        ""fmla v18.4s, v10.4s, v2.s[1] \\n""
        ""fmla v19.4s, v11.4s, v2.s[1] \\n""
        ""fmla v20.4s, v10.4s, v2.s[2] \\n""
        ""fmla v21.4s, v11.4s, v2.s[2] \\n""
        ""fmla v22.4s, v10.4s, v2.s[3] \\n""
        ""fmla v23.4s, v11.4s, v2.s[3] \\n""

        ""fmla v24.4s, v10.4s, v3.s[0] \\n""
        ""fmla v25.4s, v11.4s, v3.s[0] \\n""
        ""fmla v26.4s, v10.4s, v3.s[1] \\n""
        ""fmla v27.4s, v11.4s, v3.s[1] \\n""
        ""fmla v28.4s, v10.4s, v3.s[2] \\n""
        ""fmla v29.4s, v11.4s, v3.s[2] \\n""
        ""fmla v30.4s, v10.4s, v3.s[3] \\n""
        ""fmla v31.4s, v11.4s, v3.s[3] \\n""

        ""fmla v16.4s, v12.4s, v4.s[0] \\n""
        ""fmla v17.4s, v13.4s, v4.s[0] \\n""
        ""fmla v18.4s, v12.4s, v4.s[1] \\n""
        ""fmla v19.4s, v13.4s, v4.s[1] \\n""
        ""fmla v20.4s, v12.4s, v4.s[2] \\n""
        ""fmla v21.4s, v13.4s, v4.s[2] \\n""
        ""fmla v22.4s, v12.4s, v4.s[3] \\n""
        ""fmla v23.4s, v13.4s, v4.s[3] \\n""

        ""fmla v24.4s, v12.4s, v5.s[0] \\n""
        ""fmla v25.4s, v13.4s, v5.s[0] \\n""
        ""fmla v26.4s, v12.4s, v5.s[1] \\n""
        ""fmla v27.4s, v13.4s, v5.s[1] \\n""
        ""fmla v28.4s, v12.4s, v5.s[2] \\n""
        ""fmla v29.4s, v13.4s, v5.s[2] \\n""
        ""fmla v30.4s, v12.4s, v5.s[3] \\n""
        ""fmla v31.4s, v13.4s, v5.s[3] \\n""

        ""fmla v16.4s, v14.4s, v6.s[0] \\n""
        ""fmla v17.4s, v15.4s, v6.s[0] \\n""
        ""fmla v18.4s, v14.4s, v6.s[1] \\n""
        ""fmla v19.4s, v15.4s, v6.s[1] \\n""
        ""fmla v20.4s, v14.4s, v6.s[2] \\n""
        ""fmla v21.4s, v15.4s, v6.s[2] \\n""
        ""fmla v22.4s, v14.4s, v6.s[3] \\n""
        ""fmla v23.4s, v15.4s, v6.s[3] \\n""

        ""fmla v24.4s, v14.4s, v7.s[0] \\n""
        ""fmla v25.4s, v15.4s, v7.s[0] \\n""
        ""fmla v26.4s, v14.4s, v7.s[1] \\n""
        ""fmla v27.4s, v15.4s, v7.s[1] \\n""
        ""fmla v28.4s, v14.4s, v7.s[2] \\n""
        ""fmla v29.4s, v15.4s, v7.s[2] \\n""
        ""fmla v30.4s, v14.4s, v7.s[3] \\n""
        ""fmla v31.4s, v15.4s, v7.s[3] \\n""

        ""st1 {v16.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v17.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v18.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v19.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v20.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v21.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v22.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v23.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v24.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v25.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v26.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v27.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v28.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v29.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v30.4s}, [%[packed_output_data]], #16 \\n""
        ""st1 {v31.4s}, [%[packed_output_data]], #16 \\n""
    :  // outputs
    [lhs_ptr] ""+r""(lhs_ptr),
    [rhs_ptr] ""+r""(rhs_ptr),
    [packed_output_data] ""+r""(packed_output_data),
    [r_depth_block_count] ""+r""(r_depth_block_count)
    :  // inputs
    :  // clabbers
    ""cc"", ""memory"",
        ""v0"", ""v1"", ""v2"", ""v3"", ""v4"", ""v5"", ""v6"", ""v7"",
        ""v8"", ""v9"", ""v10"", ""v11"", ""v12"", ""v13"", ""v14"", ""v15"",
        ""v16"", ""v17"", ""v18"", ""v19"", ""v20"", ""v21"", ""v22"", ""v23"",
        ""v24"", ""v25"", ""v26"", ""v27"", ""v28"", ""v29"", ""v30"", ""v31"");
  }
#else  // armeabi-v7a
  // Register layout: (4x4) x (4,8)
  //
  //                               +--------+--------+
  //                               | q4 ... | q5 ... |
  //                       Rhs     +--------+--------+
  //                               | q6 ... | q7 ... |
  //                               +--------+--------+
  //                               | q4 ... | q5 ... |
  //                               +--------+--------+
  //                               | q6 ... | q7 ... |
  //                               +--------+--------+
  //
  //          Lhs
  //
  //  +----+----+----+----+  -  -  +--------+--------+
  //  | q0 | q1 | q2 | q3 |        | q8...  | q9...  |
  //  | .  |    |    |    |        | q10... | q11... |
  //  | .  |    |    |    |        | q12... | q13... |
  //  | .  |    |    |    |        | q14... | q15... |
  //  +----+----+----+----+        +--------+--------+
  //
  //                                    Accumulator
  //

  if (depth_block_count > 0) {
    index_t r_depth_block_count = depth_block_count;
    // just make compiler happy
    MACE_UNUSED(r_depth_block_count);

    asm volatile(
    ""mov r0, #0\\n""
    ""vdup.f32 q8, r0 \\n""
    ""vdup.f32 q9, r0 \\n""
    ""vdup.f32 q10, r0 \\n""
    ""vdup.f32 q11, r0 \\n""
    ""vdup.f32 q12, r0 \\n""
    ""vdup.f32 q13, r0 \\n""
    ""vdup.f32 q14, r0 \\n""
    ""vdup.f32 q15, r0 \\n""

    // prelogue
    ""vld1.f32 {d0-d1}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d2-d3}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d4-d5}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d6-d7}, [%[lhs_ptr]]! \\n""

    ""vld1.f32 {d8-d9}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d10-d11}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d12-d13}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d14-d15}, [%[rhs_ptr]]! \\n""

    ""subs %[r_depth_block_count], %[r_depth_block_count], #1 \\n""
    ""beq 1f\\n""

    ""0: \\n""

    ""vmla.f32 q8, q4, d0[0] \\n""
    ""vmla.f32 q9, q5, d0[0] \\n""
    ""vmla.f32 q10, q4, d0[1] \\n""
    ""vmla.f32 q11, q5, d0[1] \\n""
    ""vmla.f32 q12, q4, d1[0] \\n""
    ""vmla.f32 q13, q5, d1[0] \\n""
    ""vmla.f32 q14, q4, d1[1] \\n""
    ""vmla.f32 q15, q5, d1[1] \\n""

    ""vld1.f32 {d0-d1}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d8-d9}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d10-d11}, [%[rhs_ptr]]! \\n""

    ""vmla.f32 q8, q6, d2[0] \\n""
    ""vmla.f32 q9, q7, d2[0] \\n""
    ""vmla.f32 q10, q6, d2[1] \\n""
    ""vmla.f32 q11, q7, d2[1] \\n""
    ""vmla.f32 q12, q6, d3[0] \\n""
    ""vmla.f32 q13, q7, d3[0] \\n""
    ""vmla.f32 q14, q6, d3[1] \\n""
    ""vmla.f32 q15, q7, d3[1] \\n""

    ""vld1.f32 {d2-d3}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d12-d13}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d14-d15}, [%[rhs_ptr]]! \\n""

    ""vmla.f32 q8, q4, d4[0] \\n""
    ""vmla.f32 q9, q5, d4[0] \\n""
    ""vmla.f32 q10, q4, d4[1] \\n""
    ""vmla.f32 q11, q5, d4[1] \\n""
    ""vmla.f32 q12, q4, d5[0] \\n""
    ""vmla.f32 q13, q5, d5[0] \\n""
    ""vmla.f32 q14, q4, d5[1] \\n""
    ""vmla.f32 q15, q5, d5[1] \\n""

    ""vld1.f32 {d4-d5}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d8-d9}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d10-d11}, [%[rhs_ptr]]! \\n""

    ""subs %[r_depth_block_count], %[r_depth_block_count], #1 \\n""

    ""vmla.f32 q8, q6, d6[0] \\n""
    ""vmla.f32 q9, q7, d6[0] \\n""
    ""vmla.f32 q10, q6, d6[1] \\n""
    ""vmla.f32 q11, q7, d6[1] \\n""
    ""vmla.f32 q12, q6, d7[0] \\n""
    ""vmla.f32 q13, q7, d7[0] \\n""
    ""vmla.f32 q14, q6, d7[1] \\n""
    ""vmla.f32 q15, q7, d7[1] \\n""

    ""vld1.f32 {d6-d7}, [%[lhs_ptr]]! \\n""
    ""vld1.f32 {d12-d13}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d14-d15}, [%[rhs_ptr]]! \\n""

    ""bne 0b \\n""

    // prologue
    ""1:\\n""
    ""vmla.f32 q8, q4, d0[0] \\n""
    ""vmla.f32 q9, q5, d0[0] \\n""
    ""vmla.f32 q10, q4, d0[1] \\n""
    ""vmla.f32 q11, q5, d0[1] \\n""
    ""vmla.f32 q12, q4, d1[0] \\n""
    ""vmla.f32 q13, q5, d1[0] \\n""
    ""vmla.f32 q14, q4, d1[1] \\n""
    ""vmla.f32 q15, q5, d1[1] \\n""

    ""vld1.f32 {d8-d9}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d10-d11}, [%[rhs_ptr]]! \\n""

    ""vmla.f32 q8, q6, d2[0] \\n""
    ""vmla.f32 q9, q7, d2[0] \\n""
    ""vmla.f32 q10, q6, d2[1] \\n""
    ""vmla.f32 q11, q7, d2[1] \\n""
    ""vmla.f32 q12, q6, d3[0] \\n""
    ""vmla.f32 q13, q7, d3[0] \\n""
    ""vmla.f32 q14, q6, d3[1] \\n""
    ""vmla.f32 q15, q7, d3[1] \\n""

    ""vld1.f32 {d12-d13}, [%[rhs_ptr]]! \\n""
    ""vld1.f32 {d14-d15}, [%[rhs_ptr]]! \\n""

    ""vmla.f32 q8, q4, d4[0] \\n""
    ""vmla.f32 q9, q5, d4[0] \\n""
    ""vmla.f32 q10, q4, d4[1] \\n""
    ""vmla.f32 q11, q5, d4[1] \\n""
    ""vmla.f32 q12, q4, d5[0] \\n""
    ""vmla.f32 q13, q5, d5[0] \\n""
    ""vmla.f32 q14, q4, d5[1] \\n""
    ""vmla.f32 q15, q5, d5[1] \\n""

    ""vmla.f32 q8, q6, d6[0] \\n""
    ""vmla.f32 q9, q7, d6[0] \\n""
    ""vmla.f32 q10, q6, d6[1] \\n""
    ""vmla.f32 q11, q7, d6[1] \\n""
    ""vmla.f32 q12, q6, d7[0] \\n""
    ""vmla.f32 q13, q7, d7[0] \\n""
    ""vmla.f32 q14, q6, d7[1] \\n""
    ""vmla.f32 q15, q7, d7[1] \\n""

    ""vst1.f32 {d16-d17}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d18-d19}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d20-d21}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d22-d23}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d24-d25}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d26-d27}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d28-d29}, [%[packed_output_data]]! \\n""
    ""vst1.f32 {d30-d31}, [%[packed_output_data]]! \\n""
    :  // outputs
    [lhs_ptr] ""+r""(lhs_ptr),
    [rhs_ptr] ""+r""(rhs_ptr),
    [packed_output_data] ""+r""(packed_output_data),
    [r_depth_block_count] ""+r""(r_depth_block_count)
    :  // inputs
    :  // clabbers
    ""cc"", ""memory"", ""r0"",
        ""q0"", ""q1"", ""q2"", ""q3"", ""q4"", ""q5"", ""q6"", ""q7"",
        ""q8"", ""q9"", ""q10"", ""q11"", ""q12"", ""q13"", ""q14"", ""q15"");
  }
#endif
}

void Gemm::PackLhs(const MatrixMap<const float> &lhs,
                   float *packed_lhs) {
#ifdef __aarch64__
  Pack<8, 4>(lhs, ColMajor, packed_lhs);
#else
  Pack<4, 4>(lhs, ColMajor, packed_lhs);
#endif
}

void Gemm::PackRhs(const MatrixMap<const float> &rhs,
                   float *packed_rhs) {
  Pack<8, 4>(rhs, RowMajor, packed_rhs);
}

void Gemm::UnpackOutput(const float *packed_output, MatrixMap<float> *output) {
#ifdef __aarch64__
  Unpack<8, 8>(packed_output, output);
#else
  Unpack<4, 8>(packed_output, output);
#endif
}

template<>
void Gemm::Pack<4, 4>(const MatrixMap<const float> &matrix,
                      MatrixMajor dst_major,
                      float *packed_matrix) {
  const index_t rows = matrix.rows();
  const index_t cols = matrix.cols();

  // use the same terminology as GemmLowp:
  // depth is depth, width is the opposite dim other than depth
  // lhs
  index_t width = rows;
  index_t depth = cols;
  index_t width_stride = matrix.rows_stride();
  index_t depth_stride = matrix.cols_stride();
  if (dst_major == RowMajor) {
    // rhs
    std::swap(width, depth);
    std::swap(width_stride, depth_stride);
  }
  const float *data = matrix.data();
  float *packed_ptr = packed_matrix;

  const index_t block_size = 4;
  const index_t depth_padded = RoundUp(depth, static_cast<index_t>(4));

  if (depth_padded > depth) {
    memset(packed_ptr + depth * block_size,
           0,
           sizeof(float) * (depth_padded - depth) * block_size);
  }

  if (dst_major == matrix.matrix_major()) {
    if (width < block_size) {
      const index_t width_remain = block_size - width;
      for (index_t d = 0; d < depth; ++d) {
        memcpy(packed_ptr, data, sizeof(float) * width);
        memset(packed_ptr + width, 0, sizeof(float) * width_remain);
        data += depth_stride;
        packed_ptr += block_size;
      }
    } else {
      for (index_t d = 0; d < depth; ++d) {
        float32x4_t vi = vld1q_f32(data);
        vst1q_f32(packed_ptr, vi);
        data += depth_stride;
        packed_ptr += block_size;
      }
    }
  } else {
    if (width < block_size) {
      const index_t width_remain = block_size - width;
      for (index_t d = 0; d < depth; ++d) {
        for (index_t w = 0; w < width; ++w) {
          packed_ptr[w] = data[w * width_stride + d];
        }  // w
        memset(packed_ptr + width, 0, sizeof(float) * width_remain);
        packed_ptr += block_size;
      }  // d
    } else {
      const float *data0 = data;
      const float *data1 = data + width_stride;
      const float *data2 = data1 + width_stride;
      const float *data3 = data2 + width_stride;

      const index_t depth_block = depth / 4;
      const index_t depth_remain = depth - depth_block * 4;
      for (index_t depth_block_idx = 0; depth_block_idx < depth_block;
           ++depth_block_idx) {
        float32x4_t v0 = vld1q_f32(data0);
        float32x4_t v1 = vld1q_f32(data1);
        float32x4_t v2 = vld1q_f32(data2);
        float32x4_t v3 = vld1q_f32(data3);
        float32x4x2_t v02_intertwined = vzipq_f32(v0, v2);
        float32x4x2_t v13_intertwined = vzipq_f32(v1, v3);
        float32x4x2_t v0123_intertwined =
            vzipq_f32(v02_intertwined.val[0], v13_intertwined.val[0]);
        float32x4x2_t v0123n_intertwined =
            vzipq_f32(v02_intertwined.val[1], v13_intertwined.val[1]);

        vst1q_f32(packed_ptr, v0123_intertwined.val[0]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v0123_intertwined.val[1]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v0123n_intertwined.val[0]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v0123n_intertwined.val[1]);
        packed_ptr += 4;

        data0 += 4;
        data1 += 4;
        data2 += 4;
        data3 += 4;
      }
      for (index_t d = 0; d < depth_remain; ++d) {
        float32x4_t vi = {*data0, *data1, *data2, *data3};
        vst1q_f32(packed_ptr, vi);
        packed_ptr += 4;

        ++data0;
        ++data1;
        ++data2;
        ++data3;
      }  // d
    }
  }
}

template<>
void Gemm::Pack<8, 4>(const MatrixMap<const float> &matrix,
                      MatrixMajor dst_major,
                      float *packed_matrix) {
  const index_t rows = matrix.rows();
  const index_t cols = matrix.cols();

  // use the same terminology as GemmLowp:
  // depth is depth, width is the opposite dim other than depth
  // lhs
  index_t width = rows;
  index_t depth = cols;
  index_t width_stride = matrix.rows_stride();
  index_t depth_stride = matrix.cols_stride();
  if (dst_major == RowMajor) {
    // rhs
    std::swap(width, depth);
    std::swap(width_stride, depth_stride);
  }
  const float *data = matrix.data();
  float *packed_ptr = packed_matrix;

  const index_t block_size = 8;
  const index_t depth_padded = RoundUp(depth, static_cast<index_t>(4));

  if (depth_padded > depth) {
    memset(packed_ptr + depth * block_size,
           0,
           sizeof(float) * (depth_padded - depth) * block_size);
  }

  if (dst_major == matrix.matrix_major()) {
    if (width < block_size) {
      const index_t width_remain = block_size - width;
      for (index_t d = 0; d < depth; ++d) {
        memcpy(packed_ptr, data, sizeof(float) * width);
        memset(packed_ptr + width, 0, sizeof(float) * width_remain);
        data += depth_stride;
        packed_ptr += block_size;
      }
    } else {
      for (index_t d = 0; d < depth; ++d) {
        float32x4_t vi = vld1q_f32(data);
        vst1q_f32(packed_ptr, vi);
        float32x4_t vin = vld1q_f32(data + 4);
        vst1q_f32(packed_ptr + 4, vin);
        data += depth_stride;
        packed_ptr += block_size;
      }
    }
  } else {
    if (width < block_size) {
      const index_t width_remain = block_size - width;
      for (index_t d = 0; d < depth; ++d) {
        for (index_t w = 0; w < width; ++w) {
          packed_ptr[w] = data[w * width_stride + d];
        }  // w
        memset(packed_ptr + width, 0, sizeof(float) * width_remain);
        packed_ptr += block_size;
      }  // d
    } else {
      const float *data0 = data;
      const float *data1 = data + width_stride;
      const float *data2 = data1 + width_stride;
      const float *data3 = data2 + width_stride;
      const float *data4 = data3 + width_stride;
      const float *data5 = data4 + width_stride;
      const float *data6 = data5 + width_stride;
      const float *data7 = data6 + width_stride;

      const index_t depth_block = depth / 4;
      const index_t depth_remain = depth - depth_block * 4;
      for (index_t depth_block_idx = 0; depth_block_idx < depth_block;
           ++depth_block_idx) {
        float32x4_t v0 = vld1q_f32(data0);
        float32x4_t v1 = vld1q_f32(data1);
        float32x4_t v2 = vld1q_f32(data2);
        float32x4_t v3 = vld1q_f32(data3);
        float32x4x2_t v02_intertwined = vzipq_f32(v0, v2);
        float32x4x2_t v13_intertwined = vzipq_f32(v1, v3);
        float32x4x2_t v0123_intertwined =
            vzipq_f32(v02_intertwined.val[0], v13_intertwined.val[0]);
        float32x4x2_t v0123n_intertwined =
            vzipq_f32(v02_intertwined.val[1], v13_intertwined.val[1]);

        float32x4_t v4 = vld1q_f32(data4);
        float32x4_t v5 = vld1q_f32(data5);
        float32x4_t v6 = vld1q_f32(data6);
        float32x4_t v7 = vld1q_f32(data7);
        float32x4x2_t v46_intertwined = vzipq_f32(v4, v6);
        float32x4x2_t v57_intertwined = vzipq_f32(v5, v7);
        float32x4x2_t v4567_intertwined =
            vzipq_f32(v46_intertwined.val[0], v57_intertwined.val[0]);
        float32x4x2_t v4567n_intertwined =
            vzipq_f32(v46_intertwined.val[1], v57_intertwined.val[1]);

        vst1q_f32(packed_ptr, v0123_intertwined.val[0]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v4567_intertwined.val[0]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v0123_intertwined.val[1]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v4567_intertwined.val[1]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v0123n_intertwined.val[0]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v4567n_intertwined.val[0]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v0123n_intertwined.val[1]);
        packed_ptr += 4;

        vst1q_f32(packed_ptr, v4567n_intertwined.val[1]);
        packed_ptr += 4;

        data0 += 4;
        data1 += 4;
        data2 += 4;
        data3 += 4;
        data4 += 4;
        data5 += 4;
        data6 += 4;
        data7 += 4;
      }
      for (index_t d = 0; d < depth_remain; ++d) {
        float32x4_t vi = {*data0, *data1, *data2, *data3};
        vst1q_f32(packed_ptr, vi);
        packed_ptr += 4;

        float32x4_t vin = {*data4, *data5, *data6, *data7};
        vst1q_f32(packed_ptr, vin);
        packed_ptr += 4;

        ++data0;
        ++data1;
        ++data2;
        ++data3;
        ++data4;
        ++data5;
        ++data6;
        ++data7;
      }  // d
    }
  }
}

template<>
void Gemm::Unpack<4, 8>(const float *packed_output, MatrixMap<float> *output) {
  const index_t rows = output->rows();
  const index_t cols = output->cols();
  index_t row_stride = output->rows_stride();
  index_t col_stride = output->cols_stride();

  float *output_ptr = output->data();
  const float *packed_ptr = packed_output;

  const index_t block_size = 8;

  // packed_output always has row-major
  if (output->matrix_major() == RowMajor) {
    if (cols < block_size) {
      for (index_t r = 0; r < rows; ++r) {
        memcpy(output_ptr, packed_ptr, sizeof(float) * cols);
        output_ptr += row_stride;
        packed_ptr += block_size;
      }
    } else {
      for (index_t r = 0; r < rows; ++r) {
        float32x4_t vi = vld1q_f32(packed_ptr);
        vst1q_f32(output_ptr, vi);
        float32x4_t vin = vld1q_f32(packed_ptr + 4);
        vst1q_f32(output_ptr + 4, vin);

        output_ptr += row_stride;
        packed_ptr += block_size;
      }
    }
  } else {
    // ColMajor
    if (rows < block_size) {
      for (index_t c = 0; c < cols; ++c) {
        for (index_t r = 0; r < rows; ++r) {
          output_ptr[c * col_stride + r] = packed_ptr[r * block_size + c];
        }  // r
      }  // c
    } else {
      const float *data0 = packed_ptr;
      const float *data1 = data0 + block_size;
      const float *data2 = data1 + block_size;
      const float *data3 = data2 + block_size;

      index_t col_block = cols / 4;
      index_t col_remain = cols - col_block * 4;
      for (index_t col_block_idx = 0; col_block_idx < col_block;
           ++col_block_idx) {
        float32x4_t v0 = vld1q_f32(data0);
        float32x4_t v1 = vld1q_f32(data1);
        float32x4_t v2 = vld1q_f32(data2);
        float32x4_t v3 = vld1q_f32(data3);
        float32x4x2_t v02_intertwined = vzipq_f32(v0, v2);
        float32x4x2_t v13_intertwined = vzipq_f32(v1, v3);
        float32x4x2_t v0123_intertwined =
            vzipq_f32(v02_intertwined.val[0], v13_intertwined.val[0]);
        float32x4x2_t v0123n_intertwined =
            vzipq_f32(v02_intertwined.val[1], v13_intertwined.val[1]);

        vst1q_f32(output_ptr, v0123_intertwined.val[0]);
        output_ptr += col_stride;

        vst1q_f32(output_ptr, v0123_intertwined.val[1]);
        output_ptr += col_stride;

        vst1q_f32(output_ptr, v0123n_intertwined.val[0]);
        output_ptr += col_stride;

        vst1q_f32(output_ptr, v0123n_intertwined.val[1]);
        output_ptr += col_stride;

        data0 += 4;
        data1 += 4;
        data2 += 4;
        data3 += 4;
      }
      for (index_t c = 0; c < col_remain; ++c) {
        float32x4_t vi = {*data0, *data1, *data2, *data3};
        vst1q_f32(output_ptr, vi);
        output_ptr += col_stride;

        ++data0;
        ++data1;
        ++data2;
        ++data3;
      }  // d
    }
  }
}

template<>
void Gemm::Unpack<8, 8>(const float *packed_output, MatrixMap<float> *output) {
  const index_t rows = output->rows();
  const index_t cols = output->cols();
  index_t row_stride = output->rows_stride();
  index_t col_stride = output->cols_stride();

  float *output_ptr = output->data();
  const float *packed_ptr = packed_output;

  const index_t block_size = 8;

  // packed_output always has row-major
  if (output->matrix_major() == RowMajor) {
    if (cols < block_size) {
      for (index_t r = 0; r < rows; ++r) {
        memcpy(output_ptr, packed_ptr, sizeof(float) * cols);
        output_ptr += row_stride;
        packed_ptr += block_size;
      }
    } else {
      for (index_t r = 0; r < rows; ++r) {
        float32x4_t vi = vld1q_f32(packed_ptr);
        vst1q_f32(output_ptr, vi);
        float32x4_t vin = vld1q_f32(packed_ptr + 4);
        vst1q_f32(output_ptr + 4, vin);

        output_ptr += row_stride;
        packed_ptr += block_size;
      }
    }
  } else {
    // ColMajor
    if (rows < block_size) {
      for (index_t c = 0; c < cols; ++c) {
        for (index_t r = 0; r < rows; ++r) {
          output_ptr[c * col_stride + r] = packed_ptr[r * block_size + c];
        }  // r
      }  // c
    } else {
      const float *data0 = packed_ptr;
      const float *data1 = data0 + block_size;
      const float *data2 = data1 + block_size;
      const float *data3 = data2 + block_size;
      const float *data4 = data3 + block_size;
      const float *data5 = data4 + block_size;
      const float *data6 = data5 + block_size;
      const float *data7 = data6 + block_size;

      index_t col_block = cols / 4;
      index_t col_remain = cols - col_block * 4;
      for (index_t col_block_idx = 0; col_block_idx < col_block;
           ++col_block_idx) {
        float32x4_t v0 = vld1q_f32(data0);
        float32x4_t v1 = vld1q_f32(data1);
        float32x4_t v2 = vld1q_f32(data2);
        float32x4_t v3 = vld1q_f32(data3);
        float32x4x2_t v02_intertwined = vzipq_f32(v0, v2);
        float32x4x2_t v13_intertwined = vzipq_f32(v1, v3);
        float32x4x2_t v0123_intertwined =
            vzipq_f32(v02_intertwined.val[0], v13_intertwined.val[0]);
        float32x4x2_t v0123n_intertwined =
            vzipq_f32(v02_intertwined.val[1], v13_intertwined.val[1]);

        float32x4_t v4 = vld1q_f32(data4);
        float32x4_t v5 = vld1q_f32(data5);
        float32x4_t v6 = vld1q_f32(data6);
        float32x4_t v7 = vld1q_f32(data7);
        float32x4x2_t v46_intertwined = vzipq_f32(v4, v6);
        float32x4x2_t v57_intertwined = vzipq_f32(v5, v7);
        float32x4x2_t v4567_intertwined =
            vzipq_f32(v46_intertwined.val[0], v57_intertwined.val[0]);
        float32x4x2_t v4567n_intertwined =
            vzipq_f32(v46_intertwined.val[1], v57_intertwined.val[1]);

        vst1q_f32(output_ptr, v0123_intertwined.val[0]);
        vst1q_f32(output_ptr + 4, v4567_intertwined.val[0]);
        output_ptr += col_stride;

        vst1q_f32(output_ptr, v0123_intertwined.val[1]);
        vst1q_f32(output_ptr + 4, v4567_intertwined.val[1]);
        output_ptr += col_stride;

        vst1q_f32(output_ptr, v0123n_intertwined.val[0]);
        vst1q_f32(output_ptr + 4, v4567n_intertwined.val[0]);
        output_ptr += col_stride;

        vst1q_f32(output_ptr, v0123n_intertwined.val[1]);
        vst1q_f32(output_ptr + 4, v4567n_intertwined.val[1]);
        output_ptr += col_stride;

        data0 += 4;
        data1 += 4;
        data2 += 4;
        data3 += 4;
        data4 += 4;
        data5 += 4;
        data6 += 4;
        data7 += 4;
      }
      for (index_t c = 0; c < col_remain; ++c) {
        float32x4_t vi = {*data0, *data1, *data2, *data3};
        vst1q_f32(output_ptr, vi);
        float32x4_t vin = {*data4, *data5, *data6, *data7};
        vst1q_f32(output_ptr + 4, vin);
        output_ptr += col_stride;

        ++data0;
        ++data1;
        ++data2;
        ++data3;
        ++data4;
        ++data5;
        ++data6;
        ++data7;
      }  // d
    }
  }
}

MaceStatus Gemm::Compute(const OpContext *context,
                         const Tensor *lhs,
                         const Tensor *rhs,
                         const index_t batch,
                         const index_t lhs_rows,
                         const index_t lhs_cols,
                         const index_t rhs_rows,
                         const index_t rhs_cols,
                         const bool transpose_lhs,
                         const bool transpose_rhs,
                         const bool transpose_out,
                         const bool lhs_batched,
                         const bool rhs_batched,
                         Tensor *output) {
  index_t rows = transpose_lhs ? lhs_cols : lhs_rows;
  index_t depth = transpose_lhs ? lhs_rows : lhs_cols;
  index_t cols = transpose_rhs ? rhs_rows : rhs_cols;
  index_t depth2 = transpose_rhs ? rhs_cols : rhs_rows;
  MACE_CHECK(depth == depth2,
             ""Matrices that multiply have inconsistent depth dim: "",
             depth,
             "" vs. "",
             depth2);

  return Compute(context,
                 lhs,
                 rhs,
                 batch,
                 rows,
                 cols,
                 depth,
                 transpose_lhs ? ColMajor : RowMajor,
                 transpose_rhs ? ColMajor : RowMajor,
                 transpose_out ? ColMajor : RowMajor,
                 lhs_batched,
                 rhs_batched,
                 output);
}

}  // namespace fp32
}  // namespace arm
}  // namespace ops
}  // namespace mace
",16335,True,3033.838800651086,median
"////
DO NOT EDIT THIS FILE. IT WAS GENERATED.
Manual changes to this file will be lost when it is generated again.
Edit the files in the src/main/asciidoc/ directory instead.
////


= Spring Cloud Kubernetes
:doctype: book
:idprefix:
:idseparator: -
:toc: left
:toclevels: 4
:tabsize: 4
:numbered:
:sectanchors:
:sectnums:
:icons: font
:hide-uri-scheme:
:docinfo: shared,private

:sc-ext: java
:project-full-name: Spring Cloud Kubernetes
:all: {asterisk}{asterisk}

This reference guide covers how to use Spring Cloud Kubernetes.

== Why do you need Spring Cloud Kubernetes?

Spring Cloud Kubernetes provide Spring Cloud common interface implementations that consume Kubernetes native services.
The main objective of the projects provided in this repository is to facilitate the integration of Spring Cloud and Spring Boot applications running inside Kubernetes.

== Starters

Starters are convenient dependency descriptors you can include in your
application. Include a starter to get the dependencies and Spring Boot
auto-configuration for a feature set.

[cols=""a,d""]
|===
| Starter | Features

| [source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-kubernetes</artifactId>
</dependency>
----
| <<DiscoveryClient for Kubernetes,Discovery Client>> implementation that
resolves service names to Kubernetes Services.

| [source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-kubernetes-config</artifactId>
</dependency>
----
| Load application properties from Kubernetes
<<ConfigMap PropertySource,ConfigMaps>> and <<Secrets PropertySource,Secrets>>.
<<PropertySource Reload,Reload>> application properties when a ConfigMap or
Secret changes.

| [source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-kubernetes-all</artifactId>
</dependency>
----
| All Spring Cloud Kubernetes features.

|===

== DiscoveryClient for Kubernetes

This project provides an implementation of https://github.com/spring-cloud/spring-cloud-commons/blob/master/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/DiscoveryClient.java[Discovery Client]
for https://kubernetes.io[Kubernetes].
This client lets you query Kubernetes endpoints (see https://kubernetes.io/docs/user-guide/services/[services]) by name.
A service is typically exposed by the Kubernetes API server as a collection of endpoints that represent `http` and `https` addresses and that a client can
access from a Spring Boot application running as a pod.

This is something that you get for free by adding the following dependency inside your project:

====
[source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-kubernetes</artifactId>
</dependency>
----
====

To enable loading of the `DiscoveryClient`, add `@EnableDiscoveryClient` to the according configuration or application class, as the following example shows:

====
[source,java]
----
@SpringBootApplication
@EnableDiscoveryClient
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}
----
====

Then you can inject the client in your code simply by autowiring it, as the following example shows:

====
[source,java]
----
@Autowired
private DiscoveryClient discoveryClient;
----
====

You can choose to enable `DiscoveryClient` from all namespaces by setting the following property in `application.properties`:

====
[source]
----
spring.cloud.kubernetes.discovery.all-namespaces=true
----
====

If, for any reason, you need to disable the `DiscoveryClient`, you can set the following property in `application.properties`:

====
[source]
----
spring.cloud.kubernetes.discovery.enabled=false
----
====

Some Spring Cloud components use the `DiscoveryClient` in order to obtain information about the local service instance. For
this to work, you need to align the Kubernetes service name with the `spring.application.name` property.

NOTE:  `spring.application.name` has no effect as far as the name registered for the application within Kubernetes

Spring Cloud Kubernetes can also watch the Kubernetes service catalog for changes and update the
`DiscoveryClient` implementation accordingly.  In order to enable this functionality you need to add
`@EnableScheduling` on a configuration class in your application.

== Kubernetes native service discovery

Kubernetes itself is capable of (server side) service discovery (see: https://kubernetes.io/docs/concepts/services-networking/service/#discovering-services).
Using native kubernetes service discovery ensures compatibility with additional tooling, such as Istio (https://istio.io), a service mesh that is capable of load balancing, circuit breaker, failover, and much more.

The caller service then need only refer to names resolvable in a particular Kubernetes cluster. A simple implementation might use a spring `RestTemplate` that refers to a fully qualified domain name (FQDN), such as `https://{service-name}.{namespace}.svc.{cluster}.local:{service-port}`.

Additionally, you can use Hystrix for:

* Circuit breaker implementation on the caller side, by annotating the spring boot application class with `@EnableCircuitBreaker`
* Fallback functionality, by annotating the respective method with `@HystrixCommand(fallbackMethod=`

== Kubernetes PropertySource implementations

The most common approach to configuring your Spring Boot application is to create an `application.properties` or `application.yaml` or
an `application-profile.properties` or `application-profile.yaml` file that contains key-value pairs that provide customization values to your
application or Spring Boot starters. You can override these properties by specifying system properties or environment
variables.

[[configmap-propertysource]]
=== Using a `ConfigMap` `PropertySource`

Kubernetes provides a resource named https://kubernetes.io/docs/user-guide/configmap/[`ConfigMap`] to externalize the
parameters to pass to your application in the form of key-value pairs or embedded `application.properties` or `application.yaml` files.
The link:./spring-cloud-kubernetes-config[Spring Cloud Kubernetes Config] project makes Kubernetes `ConfigMap` instances available
during application bootstrapping and triggers hot reloading of beans or Spring context when changes are detected on
observed `ConfigMap` instances.

The default behavior is to create a `ConfigMapPropertySource` based on a Kubernetes `ConfigMap` that has a `metadata.name` value of either the name of
your Spring application (as defined by its `spring.application.name` property) or a custom name defined within the
`bootstrap.properties` file under the following key: `spring.cloud.kubernetes.config.name`.

However, more advanced configuration is possible where you can use multiple `ConfigMap` instances.
The `spring.cloud.kubernetes.config.sources` list makes this possible.
For example, you could define the following `ConfigMap` instances:

====
[source,yaml]
----
spring:
  application:
    name: cloud-k8s-app
  cloud:
    kubernetes:
      config:
        name: default-name
        namespace: default-namespace
        sources:
         # Spring Cloud Kubernetes looks up a ConfigMap named c1 in namespace default-namespace
         - name: c1
         # Spring Cloud Kubernetes looks up a ConfigMap named default-name in whatever namespace n2
         - namespace: n2
         # Spring Cloud Kubernetes looks up a ConfigMap named c3 in namespace n3
         - namespace: n3
           name: c3
----
====

In the preceding example, if `spring.cloud.kubernetes.config.namespace` had not been set,
the `ConfigMap` named `c1` would be looked up in the namespace that the application runs.

Any matching `ConfigMap` that is found is processed as follows:

* Apply individual configuration properties.
* Apply as `yaml` the content of any property named `application.yaml`.
* Apply as a properties file the content of any property named `application.properties`.

The single exception to the aforementioned flow is when the `ConfigMap` contains a *single* key that indicates
the file is a YAML or properties file. In that case, the name of the key does NOT have to be `application.yaml` or
`application.properties` (it can be anything) and the value of the property is treated correctly.
This features facilitates the use case where the `ConfigMap` was created by using something like the following:

====
[source]
----
kubectl create configmap game-config --from-file=/path/to/app-config.yaml
----
====

Assume that we have a Spring Boot application named `demo` that uses the following properties to read its thread pool
configuration.

* `pool.size.core`
* `pool.size.maximum`

This can be externalized to config map in `yaml` format as follows:

====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  pool.size.core: 1
  pool.size.max: 16
----
====

Individual properties work fine for most cases. However, sometimes, embedded `yaml` is more convenient. In this case, we
use a single property named `application.yaml` to embed our `yaml`, as follows:

====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.yaml: |-
    pool:
      size:
        core: 1
        max:16
----
====

The following example also works:

====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  custom-name.yaml: |-
    pool:
      size:
        core: 1
        max:16
----
====

You can also configure Spring Boot applications differently depending on active profiles that are merged together
when the `ConfigMap` is read. You can provide different property values for different profiles by using an
`application.properties` or `application.yaml` property, specifying profile-specific values, each in their own document
(indicated by the `---` sequence), as follows:

====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.yml: |-
    greeting:
      message: Say Hello to the World
    farewell:
      message: Say Goodbye
    ---
    spring:
      profiles: development
    greeting:
      message: Say Hello to the Developers
    farewell:
      message: Say Goodbye to the Developers
    ---
    spring:
      profiles: production
    greeting:
      message: Say Hello to the Ops
----
====

In the preceding case, the configuration loaded into your Spring Application with the `development` profile is as follows:

====
[source,yaml]
----
  greeting:
    message: Say Hello to the Developers
  farewell:
    message: Say Goodbye to the Developers
----
====

However, if the `production` profile is active, the configuration becomes:

====
[source,yaml]
----
  greeting:
    message: Say Hello to the Ops
  farewell:
    message: Say Goodbye
----
====

If both profiles are active, the property that appears last within the `ConfigMap` overwrites any preceding values.

Another option is to create a different config map per profile and spring boot will automatically fetch it based
on active profiles

====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.yml: |-
    greeting:
      message: Say Hello to the World
    farewell:
      message: Say Goodbye
----
====
====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo-development
data:
  application.yml: |-
    spring:
      profiles: development
    greeting:
      message: Say Hello to the Developers
    farewell:
      message: Say Goodbye to the Developers
----
====
====
[source,yaml]
----
kind: ConfigMap
apiVersion: v1
metadata:
  name: demo-production
data:
  application.yml: |-
    spring:
      profiles: production
    greeting:
      message: Say Hello to the Ops
    farewell:
      message: Say Goodbye
----
====


To tell Spring Boot which `profile` should be enabled at bootstrap, you can pass `SPRING_PROFILES_ACTIVE` environment variable.
 To do so, you can launch your Spring Boot application with an environment variable that you can define it in the PodSpec at the container specification.
 Deployment resource file, as follows:

====
[source,yaml]
----
apiVersion: apps/v1
kind: Deployment
metadata:
  name: deployment-name
  labels:
    app: deployment-name
spec:
  replicas: 1
  selector:
    matchLabels:
      app: deployment-name
  template:
    metadata:
      labels:
        app: deployment-name
    spec:
        containers:
        - name: container-name
          image: your-image
          env:
          - name: SPRING_PROFILES_ACTIVE
            value: ""development""
----
====

NOTE: You should check the security configuration section. To access config maps from inside a pod you need to have the correct
Kubernetes service accounts, roles and role bindings.

Another option for using `ConfigMap` instances is to mount them into the Pod by running the Spring Cloud Kubernetes application
and having Spring Cloud Kubernetes read them from the file system.
This behavior is controlled by the `spring.cloud.kubernetes.config.paths` property. You can use it in
addition to or instead of the mechanism described earlier.
You can specify multiple (exact) file paths in `spring.cloud.kubernetes.config.paths` by using the `,` delimiter.

NOTE: You have to provide the full exact path to each property file, because directories are not being recursively parsed.

.Properties:
[options=""header,footer""]
|===
| Name                                       | Type      | Default                      | Description
| `spring.cloud.kubernetes.config.enabled`   | `Boolean` | `true`                       | Enable ConfigMaps `PropertySource`
| `spring.cloud.kubernetes.config.name`      | `String`  | `${spring.application.name}` | Sets the name of `ConfigMap` to look up
| `spring.cloud.kubernetes.config.namespace` | `String`  | Client namespace             | Sets the Kubernetes namespace where to lookup
| `spring.cloud.kubernetes.config.paths`     | `List`    | `null`                       | Sets the paths where `ConfigMap` instances are mounted
| `spring.cloud.kubernetes.config.enableApi` | `Boolean` | `true`                       | Enable or disable consuming `ConfigMap` instances through APIs
|===

=== Secrets PropertySource

Kubernetes has the notion of https://kubernetes.io/docs/concepts/configuration/secret/[Secrets] for storing
sensitive data such as passwords, OAuth tokens, and so on. This project provides integration with `Secrets` to make secrets
accessible by Spring Boot applications. You can explicitly enable or disable This feature by setting the `spring.cloud.kubernetes.secrets.enabled` property.

When enabled, the `SecretsPropertySource` looks up Kubernetes for `Secrets` from the following sources:

. Reading recursively from secrets mounts
. Named after the application (as defined by `spring.application.name`)
. Matching some labels

*Note:*

By default, consuming Secrets through the API (points 2 and 3 above) *is not enabled* for security reasons. The permission 'list' on secrets allows clients to inspect secrets values in the specified namespace.
Further, we recommend that containers share secrets through mounted volumes.

If you enable consuming Secrets through the API, we recommend that you limit access to Secrets by using an authorization policy, such as RBAC.
For more information about risks and best practices when consuming Secrets through the API refer to https://kubernetes.io/docs/concepts/configuration/secret/#best-practices[this doc].

If the secrets are found, their data is made available to the application.

Assume that we have a spring boot application named `demo` that uses properties to read its database
configuration. We can create a Kubernetes secret by using the following command:

====
[source]
----
kubectl create secret generic db-secret --from-literal=username=user --from-literal=password=p455w0rd
----
====

The preceding command would create the following secret (which you can see by using `kubectl get secrets db-secret -o yaml`):

====
[source,yaml]
----
apiVersion: v1
data:
  password: cDQ1NXcwcmQ=
  username: dXNlcg==
kind: Secret
metadata:
  creationTimestamp: 2017-07-04T09:15:57Z
  name: db-secret
  namespace: default
  resourceVersion: ""357496""
  selfLink: /api/v1/namespaces/default/secrets/db-secret
  uid: 63c89263-6099-11e7-b3da-76d6186905a8
type: Opaque
----
====

Note that the data contains Base64-encoded versions of the literal provided by the `create` command.

Your application can then use this secret -- for example, by exporting the secret's value as environment variables:

====
[source,yaml]
----
apiVersion: v1
kind: Deployment
metadata:
  name: ${project.artifactId}
spec:
   template:
     spec:
       containers:
         - env:
            - name: DB_USERNAME
              valueFrom:
                 secretKeyRef:
                   name: db-secret
                   key: username
            - name: DB_PASSWORD
              valueFrom:
                 secretKeyRef:
                   name: db-secret
                   key: password
----
====

You can select the Secrets to consume in a number of ways:

. By listing the directories where secrets are mapped:
+
====
[source,bash]
----
-Dspring.cloud.kubernetes.secrets.paths=/etc/secrets/db-secret,etc/secrets/postgresql
----
====
+
If you have all the secrets mapped to a common root, you can set them like:
+
====
[source,bash]
----
-Dspring.cloud.kubernetes.secrets.paths=/etc/secrets
----
====

. By setting a named secret:
+
====
[source,bash]
----
-Dspring.cloud.kubernetes.secrets.name=db-secret
----
====

. By defining a list of labels:
+
====
[source,bash]
----
-Dspring.cloud.kubernetes.secrets.labels.broker=activemq
-Dspring.cloud.kubernetes.secrets.labels.db=postgresql
----
====

As the case with `ConfigMap`, more advanced configuration is also possible where you can use multiple `Secret`
instances. The `spring.cloud.kubernetes.secrets.sources` list makes this possible.
For example, you could define the following `Secret` instances:

====
[source,yaml]
----
spring:
  application:
    name: cloud-k8s-app
  cloud:
    kubernetes:
      secrets:
        name: default-name
        namespace: default-namespace
        sources:
         # Spring Cloud Kubernetes looks up a Secret named s1 in namespace default-namespace
         - name: s1
         # Spring Cloud Kubernetes looks up a Secret named default-name in whatever namespace n2
         - namespace: n2
         # Spring Cloud Kubernetes looks up a Secret named s3 in namespace n3
         - namespace: n3
           name: s3
----
====

In the preceding example, if `spring.cloud.kubernetes.secrets.namespace` had not been set,
the `Secret` named `s1` would be looked up in the namespace that the application runs.


.Properties:
[options=""header,footer""]
|===
| Name                                        | Type      | Default                      | Description
| `spring.cloud.kubernetes.secrets.enabled`   | `Boolean` | `true`                       | Enable Secrets `PropertySource`
| `spring.cloud.kubernetes.secrets.name`      | `String`  | `${spring.application.name}` | Sets the name of the secret to look up
| `spring.cloud.kubernetes.secrets.namespace` | `String`  | Client namespace             | Sets the Kubernetes namespace where to look up
| `spring.cloud.kubernetes.secrets.labels`    | `Map`     | `null`                       | Sets the labels used to lookup secrets
| `spring.cloud.kubernetes.secrets.paths`     | `List`    | `null`                       | Sets the paths where secrets are mounted (example 1)
| `spring.cloud.kubernetes.secrets.enableApi` | `Boolean` | `false`                      | Enables or disables consuming secrets through APIs (examples 2 and 3)
|===

Notes:

* The `spring.cloud.kubernetes.secrets.labels` property behaves as defined by
https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-Configuration-Binding#map-based-binding[Map-based binding].
* The `spring.cloud.kubernetes.secrets.paths` property behaves as defined by
https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-Configuration-Binding#collection-based-binding[Collection-based binding].
* Access to secrets through the API may be restricted for security reasons. The preferred way is to mount secrets to the Pod.

You can find an example of an application that uses secrets (though it has not been updated to use the new `spring-cloud-kubernetes` project) at
https://github.com/fabric8-quickstarts/spring-boot-camel-config[spring-boot-camel-config]

=== `PropertySource` Reload

WARNING:  This functionality has been deprecated in the 2020.0 release.  Please see
the <<spring-cloud-kubernetes-configuration-watcher>> controller for an alternative way
to achieve the same functionality.

Some applications may need to detect changes on external property sources and update their internal status to reflect the new configuration.
The reload feature of Spring Cloud Kubernetes is able to trigger an application reload when a related `ConfigMap` or
`Secret` changes.

By default, this feature is disabled. You can enable it by using the `spring.cloud.kubernetes.reload.enabled=true` configuration property (for example, in the `application.properties` file).

The following levels of reload are supported (by setting the `spring.cloud.kubernetes.reload.strategy` property):

* `refresh` (default): Only configuration beans annotated with `@ConfigurationProperties` or `@RefreshScope` are reloaded.
This reload level leverages the refresh feature of Spring Cloud Context.

* `restart_context`: the whole Spring `ApplicationContext` is gracefully restarted. Beans are recreated with the new configuration.
In order for the restart context functionality to work properly you must enable and expose the restart actuator endpoint
[source,yaml]
====
----
management:
  endpoint:
    restart:
      enabled: true
  endpoints:
    web:
      exposure:
        include: restart
----
====

* `shutdown`: the Spring `ApplicationContext` is shut down to activate a restart of the container.
 When you use this level, make sure that the lifecycle of all non-daemon threads is bound to the `ApplicationContext`
and that a replication controller or replica set is configured to restart the pod.

Assuming that the reload feature is enabled with default settings (`refresh` mode), the following bean is refreshed when the config map changes:

====
[java, source]
----
@Configuration
@ConfigurationProperties(prefix = ""bean"")
public class MyConfig {

    private String message = ""a message that can be changed live"";

    // getter and setters

}
----
====

To see that changes effectively happen, you can create another bean that prints the message periodically, as follows

====
[source,java]
----
@Component
public class MyBean {

    @Autowired
    private MyConfig config;

    @Scheduled(fixedDelay = 5000)
    public void hello() {
        System.out.println(""The message is: "" + config.getMessage());
    }
}
----
====

You can change the message printed by the application by using a `ConfigMap`, as follows:

====
[source,yaml]
----
apiVersion: v1
kind: ConfigMap
metadata:
  name: reload-example
data:
  application.properties: |-
    bean.message=Hello World!
----
====

Any change to the property named `bean.message` in the `ConfigMap` associated with the pod is reflected in the
output. More generally speaking, changes associated to properties prefixed with the value defined by the `prefix`
field of the `@ConfigurationProperties` annotation are detected and reflected in the application.
<<configmap-propertysource,Associating a `ConfigMap` with a pod>> is explained earlier in this chapter.

The full example is available in https://github.com/fabric8io/spring-cloud-kubernetes/tree/master/spring-cloud-kubernetes-examples/kubernetes-reload-example[`spring-cloud-kubernetes-reload-example`].

The reload feature supports two operating modes:
* Event (default): Watches for changes in config maps or secrets by using the Kubernetes API (web socket).
Any event produces a re-check on the configuration and, in case of changes, a reload.
The `view` role on the service account is required in order to listen for config map changes. A higher level role (such as `edit`) is required for secrets
(by default, secrets are not monitored).
* Polling: Periodically re-creates the configuration from config maps and secrets to see if it has changed.
You can configure the polling period by using the `spring.cloud.kubernetes.reload.period` property and defaults to 15 seconds.
It requires the same role as the monitored property source.
This means, for example, that using polling on file-mounted secret sources does not require particular privileges.

.Properties:
[options=""header,footer""]
|===
| Name                                                     | Type      | Default                      | Description
| `spring.cloud.kubernetes.reload.enabled`                 | `Boolean` | `false`                      | Enables monitoring of property sources and configuration reload
| `spring.cloud.kubernetes.reload.monitoring-config-maps`  | `Boolean` | `true`                       | Allow monitoring changes in config maps
| `spring.cloud.kubernetes.reload.monitoring-secrets`      | `Boolean` | `false`                      | Allow monitoring changes in secrets
| `spring.cloud.kubernetes.reload.strategy`               | `Enum`    | `refresh`                    | The strategy to use when firing a reload (`refresh`, `restart_context`, or `shutdown`)
| `spring.cloud.kubernetes.reload.mode`                    | `Enum`    | `event`                      | Specifies how to listen for changes in property sources (`event` or `polling`)
| `spring.cloud.kubernetes.reload.period`                  | `Duration`| `15s`                        | The period for verifying changes when using the `polling` strategy
|===

Notes:
* You should not use properties under `spring.cloud.kubernetes.reload` in config maps or secrets. Changing such properties at runtime may lead to unexpected results.
* Deleting a property or the whole config map does not restore the original state of the beans when you use the `refresh` level.

== Kubernetes Ecosystem Awareness

All of the features described earlier in this guide work equally well, regardless of whether your application is running inside
Kubernetes. This is really helpful for development and troubleshooting.
From a development point of view, this lets you start your Spring Boot application and debug one
of the modules that is part of this project. You need not deploy it in Kubernetes,
as the code of the project relies on the
https://github.com/fabric8io/kubernetes-client[Fabric8 Kubernetes Java client], which is a fluent DSL that can
communicate by using `http` protocol to the REST API of the Kubernetes Server.

To disable the integration with Kubernetes you can set `spring.cloud.kubernetes.enabled` to `false`. Please be aware that when `spring-cloud-kubernetes-config` is on the classpath,
`spring.cloud.kubernetes.enabled` should be set in `bootstrap.{properties|yml}` (or the profile specific one)  otherwise it should be in `application.{properties|yml}` (or the profile specific one).
Also note that these properties: `spring.cloud.kubernetes.config.enabled` and `spring.cloud.kubernetes.secrets.enabled` only take effect when set in `bootstrap.{properties|yml}`

=== Kubernetes Profile Autoconfiguration

When the application runs as a pod inside Kubernetes, a Spring profile named `kubernetes` automatically gets activated.
This lets you customize the configuration, to define beans that are applied when the Spring Boot application is deployed
within the Kubernetes platform (for example, different development and production configuration).

=== Istio Awareness

When you include the `spring-cloud-kubernetes-istio` module in the application classpath, a new profile is added to the application,
provided the application is running inside a Kubernetes Cluster with https://istio.io[Istio] installed. You can then use
spring `@Profile(""istio"")` annotations in your Beans and `@Configuration` classes.

The Istio awareness module uses  `me.snowdrop:istio-client` to interact with Istio APIs, letting us discover traffic rules, circuit breakers, and so on,
making it easy for our Spring Boot applications to consume this data to dynamically configure themselves according to the environment.

== Pod Health Indicator

Spring Boot uses https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthEndpoint.java[`HealthIndicator`] to expose info about the health of an application.
That makes it really useful for exposing health-related information to the user and makes it a good fit for use as https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/[readiness probes].

The Kubernetes health indicator (which is part of the core module) exposes the following info:

* Pod name, IP address, namespace, service account, node name, and its IP address
* A flag that indicates whether the Spring Boot application is internal or external to Kubernetes

== Leader Election

<TBD>

== Security Configurations Inside Kubernetes


=== Namespace

Most of the components provided in this project need to know the namespace. For Kubernetes (1.3+), the namespace is made available to the pod as part of the service account secret and is automatically detected by the client.
For earlier versions, it needs to be specified as an environment variable to the pod. A quick way to do this is as follows:

====
[source]
----
      env:
      - name: ""KUBERNETES_NAMESPACE""
        valueFrom:
          fieldRef:
            fieldPath: ""metadata.namespace""
----
====

=== Service Account

For distributions of Kubernetes that support more fine-grained role-based access within the cluster, you need to make sure a pod that runs with `spring-cloud-kubernetes` has access to the Kubernetes API.
For any service accounts you assign to a deployment or pod, you need to make sure they have the correct roles.

Depending on the requirements, you'll need `get`, `list` and `watch` permission on the following resources:

.Kubernetes Resource Permissions
|===
|Dependency | Resources


|spring-cloud-starter-kubernetes
|pods, services, endpoints

|spring-cloud-starter-kubernetes-config
|configmaps, secrets
|===

For development purposes, you can add `cluster-reader` permissions to your `default` service account. On a production system you'll likely want to provide more granular permissions.

The following Role and RoleBinding are an example for namespaced permissions for the `default` account:

====
[source,yaml]
----
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: YOUR-NAME-SPACE
  name: namespace-reader
rules:
  - apiGroups: ["""", ""extensions"", ""apps""]
    resources: [""configmaps"", ""pods"", ""services"", ""endpoints"", ""secrets""]
    verbs: [""get"", ""list"", ""watch""]

---

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: namespace-reader-binding
  namespace: YOUR-NAME-SPACE
subjects:
- kind: ServiceAccount
  name: default
  apiGroup: """"
roleRef:
  kind: Role
  name: namespace-reader
  apiGroup: """"
----
====

== Service Registry Implementation

In Kubernetes service registration is controlled by the platform, the application itself does not control
registration as it may do in other platforms.  For this reason using `spring.cloud.service-registry.auto-registration.enabled`
or setting `@EnableDiscoveryClient(autoRegister=false)` will have no effect in Spring Cloud Kubernetes.

[#spring-cloud-kubernetes-configuration-watcher]
## Spring Cloud Kubernetes Configuration Watcher

Kubernetes provides the ability to https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/#add-configmap-data-to-a-volume[mount a ConfigMap or Secret as a volume]
in the container of your application.  When the contents of the ConfigMap or Secret changes, the https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/#mounted-configmaps-are-updated-automatically[mounted volume will be updated with those changes].

However, Spring Boot will not automatically update those changes unless you restart the application.  Spring Cloud
provides the ability refresh the application context without restarting the application by either hitting the
actuator endpoint `/refresh` or via publishing a `RefreshRemoteApplicationEvent` using Spring Cloud Bus.

To achieve this configuration refresh of a Spring Cloud app running on Kubernetes, you can deploy the Spring Cloud
Kubernetes Configuration Watcher controller into your Kubernetes cluster.

The application is published as a container and is available on https://hub.docker.com/repository/docker/springcloud/spring-cloud-kubernetes-configuration-watcher[Docker Hub].

Spring Cloud Kubernetes Configuration Watcher can send refresh notifications to applications in two ways.

1.  Over HTTP in which case the application being notified must of the `/refresh` actuator endpoint exposed and accessible from within the cluster
2.  Using Spring Cloud Bus, in which case you will need a message broker deployed to your custer for the application to use.

### Deployment YAML

Below is a sample deployment YAML you can use to deploy the Kubernetes Configuration Watcher to Kubernetes.

====
[source,yaml]
----
---
apiVersion: v1
kind: List
items:
  - apiVersion: v1
    kind: Service
    metadata:
      labels:
        app: spring-cloud-kubernetes-configuration-watcher
      name: spring-cloud-kubernetes-configuration-watcher
    spec:
      ports:
        - name: http
          port: 8888
          targetPort: 8888
      selector:
        app: spring-cloud-kubernetes-configuration-watcher
      type: ClusterIP
  - apiVersion: v1
    kind: ServiceAccount
    metadata:
      labels:
        app: spring-cloud-kubernetes-configuration-watcher
      name: spring-cloud-kubernetes-configuration-watcher
  - apiVersion: rbac.authorization.k8s.io/v1
    kind: RoleBinding
    metadata:
      labels:
        app: spring-cloud-kubernetes-configuration-watcher
      name: spring-cloud-kubernetes-configuration-watcher:view
    roleRef:
      kind: Role
      apiGroup: rbac.authorization.k8s.io
      name: namespace-reader
    subjects:
      - kind: ServiceAccount
        name: spring-cloud-kubernetes-configuration-watcher
  - apiVersion: rbac.authorization.k8s.io/v1
    kind: Role
    metadata:
      namespace: default
      name: namespace-reader
    rules:
      - apiGroups: ["""", ""extensions"", ""apps""]
        resources: [""configmaps"", ""pods"", ""services"", ""endpoints"", ""secrets""]
        verbs: [""get"", ""list"", ""watch""]
  - apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: spring-cloud-kubernetes-configuration-watcher-deployment
    spec:
      selector:
        matchLabels:
          app: spring-cloud-kubernetes-configuration-watcher
      template:
        metadata:
          labels:
            app: spring-cloud-kubernetes-configuration-watcher
        spec:
          serviceAccount: spring-cloud-kubernetes-configuration-watcher
          containers:
          - name: spring-cloud-kubernetes-configuration-watcher
            image: springcloud/spring-cloud-kubernetes-configuration-watcher:2.0.0-SNAPSHOT
            imagePullPolicy: IfNotPresent
            readinessProbe:
              httpGet:
                port: 8888
                path: /actuator/health/readiness
            livenessProbe:
              httpGet:
                port: 8888
                path: /actuator/health/liveness
            ports:
            - containerPort: 8888

----
====

The Service Account and associated Role Binding is important for Spring Cloud Kubernetes Configuration to work properly.
The controller needs access to read data about ConfigMaps, Pods, Services, Endpoints and Secrets in the Kubernetes cluster.

### Monitoring ConfigMaps and Secrets

Spring Cloud Kubernetes Configuration Watcher will react to changes in ConfigMaps with a label of `spring.cloud.kubernetes.config` with the value `true`
or any Secret with a label of `spring.cloud.kubernetes.secret` with the value `true`.  If the ConfigMap or Secret does not have either of those labels
or the values of those labels is not `true` then any changes will be ignored.

The labels Spring Cloud Kubernetes Configuration Watcher looks for on ConfigMaps and Secrets can be changed by setting
`spring.cloud.kubernetes.configuration.watcher.configLabel` and `spring.cloud.kubernetes.configuration.watcher.secretLabel` respectively.

If a change is made to a ConfigMap or Secret with valid labels then Spring Cloud Kubernetes Configuration Watcher will take the name of the ConfigMap or Secret
and send a notification to the application with that name.

### HTTP Implementation

The HTTP implementation is what is used by default.  When this implementation is used Spring Cloud Kubernetes Configuration Watcher and a
change to a ConfigMap or Secret occurs then the HTTP implementation will use the Spring Cloud Kubernetes Discovery Client to fetch all
instances of the application which match the name of the ConfigMap or Secret and send an HTTP POST request to the application's actuator
`/refresh` endpoint.  By default it will send the post request to `/actuator/refresh` using the port registered in the discovery client.

#### Non-Default Management Port and Actuator Path

If the application is using a non-default actuator path and/or using a different port for the management endpoints, the Kubernetes service for the application
can add an annotation called `boot.spring.io/actuator` and set its value to the path and port used by the application.  For example

====
[source,yaml]
----
apiVersion: v1
kind: Service
metadata:
  labels:
    app: config-map-demo
  name: config-map-demo
  annotations:
    boot.spring.io/actuator: http://:9090/myactuator/home
spec:
  ports:
    - name: http
      port: 8080
      targetPort: 8080
  selector:
    app: config-map-demo
----
====


Another way you can choose to configure the actuator path and/or management port is by setting
`spring.cloud.kubernetes.configuration.watcher.actuatorPath` and `spring.cloud.kubernetes.configuration.watcher.actuatorPort`.

### Messaging Implementation

The messaging implementation can be enabled by setting the profile `bus` when the Spring Cloud Kubernetes Configuration Watcher
application is deployed to Kubernetes.

WARNING: Currently the only supported message broker is RabbitMQ

### Configuring RabbitMQ

When the `bus` profile is enabled you will need to configure Spring RabbitMQ to point it to the location of the RabbitMQ
instance you would like to use as well as any credentials necessary to authenticate.  This can be done
by setting the standard Spring RabbitMQ properties, for example

====
[source,yaml]
----
spring:
  rabbitmq:
    username: user
    password: password
    host: rabbitmq
----
====

== Examples

Spring Cloud Kubernetes tries to make it transparent for your applications to consume Kubernetes Native Services by
following the Spring Cloud interfaces.

In your applications, you need to add the `spring-cloud-kubernetes-discovery` dependency to your classpath and remove any other dependency that contains a `DiscoveryClient` implementation (that is, a Eureka discovery client).
The same applies for `PropertySourceLocator`, where you need to add to the classpath the `spring-cloud-kubernetes-config` and remove any other dependency that contains a `PropertySourceLocator` implementation (that is, a configuration server client).

The following projects highlight the usage of these dependencies and demonstrate how you can use these libraries from any Spring Boot application:

* https://github.com/spring-cloud/spring-cloud-kubernetes/tree/master/spring-cloud-kubernetes-examples[Spring Cloud Kubernetes Examples]: the ones located inside this repository.
* Spring Cloud Kubernetes Full Example: Minions and Boss
	** https://github.com/salaboy/spring-cloud-k8s-minion[Minion]
	** https://github.com/salaboy/spring-cloud-k8s-boss[Boss]
* Spring Cloud Kubernetes Full Example: https://github.com/salaboy/s1p_docs[SpringOne Platform Tickets Service]
* https://github.com/salaboy/s1p_gateway[Spring Cloud Gateway with Spring Cloud Kubernetes Discovery and Config]
* https://github.com/salaboy/showcase-admin-tool[Spring Boot Admin with Spring Cloud Kubernetes Discovery and Config]

== Other Resources

This section lists other resources, such as presentations (slides) and videos about Spring Cloud Kubernetes.

* https://salaboy.com/2018/09/27/the-s1p-experience/[S1P Spring Cloud on PKS]
* https://salaboy.com/2018/07/18/ljc-july-18-spring-cloud-docker-k8s/[Spring Cloud, Docker, Kubernetes -> London Java Community July 2018]


Please feel free to submit other resources through pull requests to https://github.com/spring-cloud/spring-cloud-kubernetes[this repository].

== Configuration properties

To see the list of all Sleuth related configuration properties please check link:appendix.html[the Appendix page].

== Building

:jdkversion: 1.7

=== Basic Compile and Test

To build the source you will need to install JDK {jdkversion}.

Spring Cloud uses Maven for most build-related activities, and you
should be able to get off the ground quite quickly by cloning the
project you are interested in and typing

----
$ ./mvnw install
----

NOTE: You can also install Maven (>=3.3.3) yourself and run the `mvn` command
in place of `./mvnw` in the examples below. If you do that you also
might need to add `-P spring` if your local Maven settings do not
contain repository declarations for spring pre-release artifacts.

NOTE: Be aware that you might need to increase the amount of memory
available to Maven by setting a `MAVEN_OPTS` environment variable with
a value like `-Xmx512m -XX:MaxPermSize=128m`. We try to cover this in
the `.mvn` configuration, so if you find you have to do it to make a
build succeed, please raise a ticket to get the settings added to
source control.

For hints on how to build the project look in `.travis.yml` if there
is one. There should be a ""script"" and maybe ""install"" command. Also
look at the ""services"" section to see if any services need to be
running locally (e.g. mongo or rabbit).  Ignore the git-related bits
that you might find in ""before_install"" since they're related to setting git
credentials and you already have those.

The projects that require middleware generally include a
`docker-compose.yml`, so consider using
https://docs.docker.com/compose/[Docker Compose] to run the middeware servers
in Docker containers. See the README in the
https://github.com/spring-cloud-samples/scripts[scripts demo
repository] for specific instructions about the common cases of mongo,
rabbit and redis.

NOTE: If all else fails, build with the command from `.travis.yml` (usually
`./mvnw install`).

=== Documentation

The spring-cloud-build module has a ""docs"" profile, and if you switch
that on it will try to build asciidoc sources from
`src/main/asciidoc`. As part of that process it will look for a
`README.adoc` and process it by loading all the includes, but not
parsing or rendering it, just copying it to `${main.basedir}`
(defaults to `${basedir}`, i.e. the root of the project). If there are
any changes in the README it will then show up after a Maven build as
a modified file in the correct place. Just commit it and push the change.

=== Working with the code
If you don't have an IDE preference we would recommend that you use
https://www.springsource.com/developer/sts[Spring Tools Suite] or
https://eclipse.org[Eclipse] when working with the code. We use the
https://eclipse.org/m2e/[m2eclipse] eclipse plugin for maven support. Other IDEs and tools
should also work without issue as long as they use Maven 3.3.3 or better.

==== Activate the Spring Maven profile
Spring Cloud projects require the 'spring' Maven profile to be activated to resolve
the spring milestone and snapshot repositories. Use your preferred IDE to set this
profile to be active, or you may experience build errors.

==== Importing into eclipse with m2eclipse
We recommend the https://eclipse.org/m2e/[m2eclipse] eclipse plugin when working with
eclipse. If you don't already have m2eclipse installed it is available from the ""eclipse
marketplace"".

NOTE: Older versions of m2e do not support Maven 3.3, so once the
projects are imported into Eclipse you will also need to tell
m2eclipse to use the right profile for the projects.  If you
see many different errors related to the POMs in the projects, check
that you have an up to date installation.  If you can't upgrade m2e,
add the ""spring"" profile to your `settings.xml`. Alternatively you can
copy the repository settings from the ""spring"" profile of the parent
pom into your `settings.xml`.

==== Importing into eclipse without m2eclipse
If you prefer not to use m2eclipse you can generate eclipse project metadata using the
following command:

[indent=0]
----
	$ ./mvnw eclipse:eclipse
----

The generated eclipse projects can be imported by selecting `import existing projects`
from the `file` menu.


== Contributing

:spring-cloud-build-branch: master

Spring Cloud is released under the non-restrictive Apache 2.0 license,
and follows a very standard Github development process, using Github
tracker for issues and merging pull requests into master. If you want
to contribute even something trivial please do not hesitate, but
follow the guidelines below.

=== Sign the Contributor License Agreement
Before we accept a non-trivial patch or pull request we will need you to sign the
https://cla.pivotal.io/sign/spring[Contributor License Agreement].
Signing the contributor's agreement does not grant anyone commit rights to the main
repository, but it does mean that we can accept your contributions, and you will get an
author credit if we do.  Active contributors might be asked to join the core team, and
given the ability to merge pull requests.

=== Code of Conduct
This project adheres to the Contributor Covenant https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[code of
conduct]. By participating, you  are expected to uphold this code. Please report
unacceptable behavior to spring-code-of-conduct@pivotal.io.

=== Code Conventions and Housekeeping
None of these is essential for a pull request, but they will all help.  They can also be
added after the original pull request but before a merge.

* Use the Spring Framework code format conventions. If you use Eclipse
  you can import formatter settings using the
  `eclipse-code-formatter.xml` file from the
  https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring
  Cloud Build] project. If using IntelliJ, you can use the
  https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter
  Plugin] to import the same file.
* Make sure all new `.java` files to have a simple Javadoc class comment with at least an
  `@author` tag identifying you, and preferably at least a paragraph on what the class is
  for.
* Add the ASF license header comment to all new `.java` files (copy from existing files
  in the project)
* Add yourself as an `@author` to the .java files that you modify substantially (more
  than cosmetic changes).
* Add some Javadocs and, if you change the namespace, some XSD doc elements.
* A few unit tests would help a lot as well -- someone has to do it.
* If no-one else is using your branch, please rebase it against the current master (or
  other target branch in the main project).
* When writing a commit message please follow https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[these conventions],
  if you are fixing an existing issue please add `Fixes gh-XXXX` at the end of the commit
  message (where XXXX is the issue number).

=== Checkstyle

Spring Cloud Build comes with a set of checkstyle rules. You can find them in the `spring-cloud-build-tools` module. The most notable files under the module are:

.spring-cloud-build-tools/
----
└── src
    ├── checkstyle
    │   └── checkstyle-suppressions.xml <3>
    └── main
        └── resources
            ├── checkstyle-header.txt <2>
            └── checkstyle.xml <1>
----
<1> Default Checkstyle rules
<2> File header setup
<3> Default suppression rules

==== Checkstyle configuration

Checkstyle rules are *disabled by default*. To add checkstyle to your project just define the following properties and plugins.

.pom.xml
----
<properties>
<maven-checkstyle-plugin.failsOnError>true</maven-checkstyle-plugin.failsOnError> <1>
        <maven-checkstyle-plugin.failsOnViolation>true
        </maven-checkstyle-plugin.failsOnViolation> <2>
        <maven-checkstyle-plugin.includeTestSourceDirectory>true
        </maven-checkstyle-plugin.includeTestSourceDirectory> <3>
</properties>

<build>
        <plugins>
            <plugin> <4>
                <groupId>io.spring.javaformat</groupId>
                <artifactId>spring-javaformat-maven-plugin</artifactId>
            </plugin>
            <plugin> <5>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
            </plugin>
        </plugins>

    <reporting>
        <plugins>
            <plugin> <5>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
            </plugin>
        </plugins>
    </reporting>
</build>
----
<1> Fails the build upon Checkstyle errors
<2> Fails the build upon Checkstyle violations
<3> Checkstyle analyzes also the test sources
<4> Add the Spring Java Format plugin that will reformat your code to pass most of the Checkstyle formatting rules
<5> Add checkstyle plugin to your build and reporting phases

If you need to suppress some rules (e.g. line length needs to be longer), then it's enough for you to define a file under `${project.root}/src/checkstyle/checkstyle-suppressions.xml` with your suppressions. Example:

.projectRoot/src/checkstyle/checkstyle-suppresions.xml
----
<?xml version=""1.0""?>
<!DOCTYPE suppressions PUBLIC
		""-//Puppy Crawl//DTD Suppressions 1.1//EN""
		""https://www.puppycrawl.com/dtds/suppressions_1_1.dtd"">
<suppressions>
	<suppress files="".*ConfigServerApplication\\.java"" checks=""HideUtilityClassConstructor""/>
	<suppress files="".*ConfigClientWatch\\.java"" checks=""LineLengthCheck""/>
</suppressions>
----

It's advisable to copy the `${spring-cloud-build.rootFolder}/.editorconfig` and `${spring-cloud-build.rootFolder}/.springformat` to your project. That way, some default formatting rules will be applied. You can do so by running this script:

```bash
$ curl https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/.editorconfig -o .editorconfig
$ touch .springformat
```

=== IDE setup

==== Intellij IDEA

In order to setup Intellij you should import our coding conventions, inspection profiles and set up the checkstyle plugin.
The following files can be found in the https://github.com/spring-cloud/spring-cloud-build/tree/master/spring-cloud-build-tools[Spring Cloud Build] project.

.spring-cloud-build-tools/
----
└── src
    ├── checkstyle
    │   └── checkstyle-suppressions.xml <3>
    └── main
        └── resources
            ├── checkstyle-header.txt <2>
            ├── checkstyle.xml <1>
            └── intellij
                ├── Intellij_Project_Defaults.xml <4>
                └── Intellij_Spring_Boot_Java_Conventions.xml <5>
----
<1> Default Checkstyle rules
<2> File header setup
<3> Default suppression rules
<4> Project defaults for Intellij that apply most of Checkstyle rules
<5> Project style conventions for Intellij that apply most of Checkstyle rules

.Code style

image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-code-style.png[Code style]

Go to `File` -> `Settings` -> `Editor` -> `Code style`. There click on the icon next to the `Scheme` section. There, click on the `Import Scheme` value and pick the `Intellij IDEA code style XML` option. Import the `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Spring_Boot_Java_Conventions.xml` file.

.Inspection profiles

image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-inspections.png[Code style]

Go to `File` -> `Settings` -> `Editor` -> `Inspections`. There click on the icon next to the `Profile` section. There, click on the `Import Profile` and import the `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Project_Defaults.xml` file.

.Checkstyle

To have Intellij work with Checkstyle, you have to install the `Checkstyle` plugin. It's advisable to also install the `Assertions2Assertj` to automatically convert the JUnit assertions

image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-checkstyle.png[Checkstyle]

Go to `File` -> `Settings` -> `Other settings` -> `Checkstyle`. There click on the `+` icon in the `Configuration file` section. There, you'll have to define where the checkstyle rules should be picked from. In the image above, we've picked the rules from the cloned Spring Cloud Build repository. However, you can point to the Spring Cloud Build's GitHub repository (e.g. for the `checkstyle.xml` : `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle.xml`). We need to provide the following variables:

- `checkstyle.header.file` - please point it to the Spring Cloud Build's, `spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` file either in your cloned repo or via the `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` URL.
- `checkstyle.suppressions.file` - default suppressions. Please point it to the Spring Cloud Build's, `spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` file either in your cloned repo or via the `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` URL.
- `checkstyle.additional.suppressions.file` - this variable corresponds to suppressions in your local project. E.g. you're working on `spring-cloud-contract`. Then point to the `project-root/src/checkstyle/checkstyle-suppressions.xml` folder. Example for `spring-cloud-contract` would be: `/home/username/spring-cloud-contract/src/checkstyle/checkstyle-suppressions.xml`.

IMPORTANT: Remember to set the `Scan Scope` to `All sources` since we apply checkstyle rules for production and test sources.
",12153,False,1798.8771572807486,median
"//
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the ""License""); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
= Getting Started with Apache NiFi
Apache NiFi Team <dev@nifi.apache.org>
:homepage: http://nifi.apache.org


== Who is This Guide For?

This guide is written for users who have never used, have had limited exposure to, or only accomplished specific tasks within NiFi.
This guide is not intended to be an exhaustive instruction manual or a reference guide. The
link:user-guide.html[User Guide] provides a great deal of information
and is intended to be a much more exhaustive resource and is very useful as a reference guide, as well.
This guide, in comparison, is intended to provide users with just the information needed in order
to understand how to work with NiFi in order to quickly and easily build powerful and agile dataflows.

Because some of the information in this guide is applicable only for first-time users while other
information may be applicable for those who have used NiFi a bit, this guide is broken up into
several different sections, some of which may not be useful for some readers. Feel free to jump to
the sections that are most appropriate for you.

This guide does expect that the user has a basic understanding of what NiFi is and does not
delve into this level of detail. This level of information can be found in the
link:overview.html[Overview] documentation.




== Terminology Used in This Guide

In order to talk about NiFi, there are a few key terms that readers should be familiar with.
We will explain those NiFi-specific terms here, at a high level.


*FlowFile*: Each piece of ""User Data"" (i.e., data that the user brings into NiFi for processing and distribution) is
referred to as a FlowFile. A FlowFile is made up of two parts: Attributes and Content. The Content is the User Data
itself. Attributes are key-value pairs that are associated with the User Data.

*Processor*: The Processor is the NiFi component that is responsible for creating, sending, receiving, transforming, routing,
splitting, merging, and processing FlowFiles. It is the most important building block available to NiFi users to build their
dataflows.


== Downloading and Installing NiFi

NiFi can be downloaded from the link:http://nifi.apache.org/download.html[NiFi Downloads Page]. There are two packaging options
available: a ""tarball"" that is tailored more to Linux and a zip file that is more applicable for Windows users. Mac OS X users
may also use the tarball or can install via Homebrew.

To install via Homebrew, simply run the command `brew install nifi`.

For users who are not running OS X or do not have Homebrew installed, after downloading the version of NiFi that you
would like to use simply extract the archive to the location that you wish to run the application from.

For information on how to configure the instance of NiFi (for example, to configure security, data storage
configuration, or the port that NiFi is running on), see the link:administration-guide.html[Admin Guide].


== Starting NiFi

Once NiFi has been downloaded and installed as described above, it can be started by using the mechanism
appropriate for your operating system.

=== For Windows Users

For Windows users, navigate to the folder where NiFi was installed. Within this folder is a subfolder
named `bin`. Navigate to this subfolder and double-click the `run-nifi.bat` file.

This will launch NiFi and leave it running in the foreground. To shut down NiFi, select the window that
was launched and hold the Ctrl key while pressing C.


=== For Linux/Mac OS X users

For Linux and OS X users, use a Terminal window to navigate to the directory where NiFi was installed.
To run NiFi in the foreground, run `bin/nifi.sh run`. This will leave the application running until
the user presses Ctrl-C. At that time, it will initiate shutdown of the application.

To run NiFi in the background, instead run `bin/nifi.sh start`. This will initiate the application to
begin running. To check the status and see if NiFi is currently running, execute the command `bin/nifi.sh status`.
NiFi can be shutdown by executing the command `bin/nifi.sh stop`.


=== Installing as a Service

Currently, installing NiFi as a service is supported only for Linux and Mac OS X users. To install the application
as a service, navigate to the installation directory in a Terminal window and execute the command `bin/nifi.sh install`
to install the service with the default name `nifi`. To specify a custom name for the service, execute the command
with an optional second argument that is the name of the service. For example, to install NiFi as a service with the
name `dataflow`, use the command `bin/nifi.sh install dataflow`.

Once installed, the service can be started and stopped using the appropriate commands, such as `sudo service nifi start`
and `sudo service nifi stop`. Additionally, the running status can be checked via `sudo service nifi status`.



== I Started NiFi. Now What?

Now that NiFi has been started, we can bring up the User Interface (UI) in order to create and monitor our dataflow.
To get started, open a web browser and navigate to `http://localhost:8080/nifi`. The port can be changed by
editing the `nifi.properties` file in the NiFi `conf` directory, but the default port is 8080.

This will bring up the User Interface, which at this point is a blank canvas for orchestrating a dataflow:

image:new-flow.png[""New Flow""]

The UI has multiple tools to create and manage your first dataflow:

image:nifi-toolbar-components.png[""Toolbar Components""]

The Global Menu contains the following options:

image:global-menu.png[""Global Menu""]


=== Adding a Processor

We can now begin creating our dataflow by adding a Processor to our canvas. To do this, drag the Processor icon
(image:iconProcessor.png[""Processor""]) from the top-left of the screen into the middle of the canvas (the graph paper-like
background) and drop it there. This will give us a dialog that allows us to choose which Processor we want to add:

image:add-processor.png[""Add Processor""]

We have quite a few options to choose from. For the sake of becoming oriented with the system, let's say that we
just want to bring in files from our local disk into NiFi. When a developer creates a Processor, the developer can
assign ""tags"" to that Processor. These can be thought of as keywords. We can filter by these tags or by Processor
name by typing into the Filter box in the top-right corner of the dialog. Type in the keywords that you would think
of when wanting to ingest files from a local disk. Typing in keyword ""file"", for instance, will provide us a few
different Processors that deal with files. Filtering by the term ""local"" will narrow down the list pretty quickly,
as well. If we select a Processor from the list,
we will see a brief description of the Processor near the bottom of the dialog. This should tell us exactly what
the Processor does. The description of the *GetFile* Processor tells us that it pulls data from our local disk
into NiFi and then removes the local file. We can then double-click the Processor type or select it and choose the
`Add` button. The Processor will be added to the canvas in the location that it was dropped.

=== Configuring a Processor

Now that we have added the GetFile Processor, we can configure it by right-clicking on the Processor and choosing
the `Configure` menu item. The provided dialog allows us to configure many different options that can be read about
in the link:user-guide.html[User Guide], but for the sake of this guide, we will focus on the Properties tab. Once
the Properties tab has been selected, we are given a list of several different properties that we can configure
for the Processor. The properties that are available depend on the type of Processor and are generally different
for each type. Properties that are in bold are required properties. The Processor cannot be started until all required
properties have been configured. The most important property to configure for GetFile is the directory from which
to pick up files. If we set the directory name to `./data-in`, this will cause the Processor to start picking up
any data in the `data-in` subdirectory of the NiFi Home directory. We can choose to configure several different
Properties for this Processor. If unsure what a particular Property does, we can hover over the Help icon (
image:iconInfo.png[""Help""]
)
next to the Property Name with the mouse in order to read a description of the property. Additionally, the
tooltip that is displayed when hovering over the Help icon will provide the default value for that property,
if one exists, information about whether or not the property supports the Expression Language (see the
<<ExpressionLanguage>> section below), and previously configured values for that property.

In order for this property to be valid, create a directory named `data-in` in the NiFi home directory and then
click the `Ok` button to close the dialog.


=== Connecting Processors

Each Processor has a set of defined ""Relationships"" that it is able to send data to. When a Processor finishes handling
a FlowFile, it transfers it to one of these Relationships. This allows a user to configure how to handle FlowFiles based
on the result of Processing. For example, many Processors define two Relationships: `success` and `failure`. Users are
then able to configure data to be routed through the flow one way if the Processor is able to successfully process
the data and route the data through the flow in a completely different manner if the Processor cannot process the
data for some reason. Or, depending on the use case, it may simply route both relationships to the same route through
the flow.

Now that we have added and configured our GetFile processor and applied the configuration, we can see in the
top-left corner of the Processor an Alert icon (
image:iconAlert.png[Alert]
) signaling that the Processor is not in a valid state. Hovering over this icon, we can see that the `success`
relationship has not been defined. This simply means that we have not told NiFi what to do with the data that the Processor
transfers to the `success` Relationship.

In order to address this, let's add another Processor that we can connect the GetFile Processor to, by following
the same steps above. This time, however, we will simply log the attributes that exist for the FlowFile. To do this,
we will add a LogAttributes Processor.

We can now send the output of the GetFile Processor to the LogAttribute Processor. Hover over the GetFile Processor
with the mouse and a Connection Icon (
image:iconConnection.png[Connection]
) will appear over the middle of the Processor. We can drag this icon from the GetFile Processor to the LogAttribute
Processor. This gives us a dialog to choose which Relationships we want to include for this connection. Because GetFile
has only a single Relationship, `success`, it is automatically selected for us.

Clicking on the Settings tab provides a handful of options for configuring how this Connection should behave:

image:connection-settings.png[Connection Settings]

We can give the Connection a name, if we like. Otherwise, the Connection name will be based on the selected Relationships.
We can also set an expiration for the data. By default, it is set to ""0 sec"" which indicates that the data should not
expire. However, we can change the value so that when data in this Connection reaches a certain age, it will automatically
be deleted (and a corresponding EXPIRE Provenance event will be created).

The backpressure thresholds allow us to specify how full the queue is allowed to become before the source Processor is
no longer scheduled to run. This allows us to handle cases where one Processor is capable of producing data faster than
the next Processor is capable of consuming that data. If the backpressure is configured for each Connection along the way,
the Processor that is bringing data into the system will eventually experience the backpressure and stop bringing in new
data so that our system has the ability to recover.

Finally, we have the Prioritizers on the right-hand side. This allows us to control how the data in this queue is ordered.
We can drag Prioritizers from the ""Available prioritizers"" list to the ""Selected prioritizers"" list in order to activate
the prioritizer. If multiple prioritizers are activated, they will be evaluated such that the Prioritizer listed first
will be evaluated first and if two FlowFiles are determined to be equal according to that Prioritizer, the second Prioritizer
will be used.

For the sake of this discussion, we can simply click `Add` to add the Connection to our graph. We should now see that the Alert
icon has changed to a Stopped icon (
image:iconStop.png[Stopped]
). The LogAttribute Processor, however, is now invalid because its `success` Relationship has not been connected to
anything. Let's address this by signaling that data that is routed to `success` by LogAttribute should be ""Auto Terminated,""
meaning that NiFi should consider the FlowFile's processing complete and ""drop"" the data. To do this, we configure the
LogAttribute Processor. On the Settings tab, in the right-hand side we can check the box next to the `success` Relationship
to Auto Terminate the data. Clicking `OK` will close the dialog and show that both Processors are now stopped.


=== Starting and Stopping Processors

At this point, we have two Processors on our graph, but nothing is happening. In order to start the Processors, we can
click on each one individually and then right-click and choose the `Start` menu item. Alternatively, we can select the first
Processor, and then hold the Shift key while selecting the other Processor in order to select both. Then, we can
right-click and choose the `Start` menu item. As an alternative to using the context menu, we can select the Processors and
then click the Start icon in the Operate palette.

Once started, the icon in the top-left corner of the Processors will change from a stopped icon to a running icon. We can then
stop the Processors by using the Stop icon in the Operate palette or the `Stop` menu item.

Once a Processor has started, we are not able to configure it anymore. Instead, when we right-click on the Processor, we are
given the option to view its current configuration. In order to configure a Processor, we must first stop the Processor and
wait for any tasks that may be executing to finish. The number of tasks currently executing is shown near the top-right
corner of the Processor, but nothing is shown there if there are currently no tasks.


=== Getting More Info for a Processor

With each Processor having the ability to expose multiple different Properties and Relationships, it can be challenging
to remember how all of the different pieces work for each Processor. To address this, you are able to right-click
on a Processor and choose the `Usage` menu item. This will provide you with the Processor's usage information, such as a
description of the Processor, the different Relationships that are available, when the different Relationships are used,
Properties that are exposed by the Processor and their documentation, as well as which FlowFile Attributes (if any) are
expected on incoming FlowFiles and which Attributes (if any) are added to outgoing FlowFiles.


=== Other Components

The toolbar that provides users the ability to drag and drop Processors onto the graph includes several other components
that can be used to build a dataflow. These components include Input and Output Ports, Funnels, Process Groups, and Remote
Process Groups. Due to the intended scope of this document, we will not discuss these elements here, but information is
readily available in the link:user-guide.html#building-dataflow[Building a Dataflow section] of the
link:user-guide.html[User Guide].



== What Processors are Available

In order to create an effective dataflow, the users must understand what types of Processors are available to them.
NiFi contains many different Processors out of the box. These Processors provide capabilities to ingest data from
numerous different systems, route, transform, process, split, and aggregate data, and distribute data to many systems.

The number of Processors that are available increases in nearly each release of NiFi. As a result, we will not attempt
to name each of the Processors that are available, but we will highlight some of the most frequently used Processors,
categorizing them by their functions.

=== Data Transformation
- *CompressContent*: Compress or Decompress Content
- *ConvertCharacterSet*: Convert the character set used to encode the content from one character set to another
- *EncryptContent*: Encrypt or Decrypt Content
- *ReplaceText*: Use Regular Expressions to modify textual Content
- *TransformXml*: Apply an XSLT transform to XML Content
- *JoltTransformJSON*: Apply a JOLT specification to transform JSON Content

=== Routing and Mediation
- *ControlRate*: Throttle the rate at which data can flow through one part of the flow
- *DetectDuplicate*: Monitor for duplicate FlowFiles, based on some user-defined criteria. Often used in conjunction
	with HashContent
- *DistributeLoad*: Load balance or sample data by distributing only a portion of data to each user-defined Relationship
- *MonitorActivity*: Sends a notification when a user-defined period of time elapses without any data coming through a particular
	point in the flow. Optionally send a notification when dataflow resumes.
- *RouteOnAttribute*: Route FlowFile based on the attributes that it contains.
- *ScanAttribute*: Scans the user-defined set of Attributes on a FlowFile, checking to see if any of the Attributes match the terms
  found in a user-defined dictionary.
- *RouteOnContent*: Search Content of a FlowFile to see if it matches any user-defined Regular Expression. If so, the FlowFile is
  routed to the configured Relationship.
- *ScanContent*: Search Content of a FlowFile for terms that are present in a user-defined dictionary and route based on the
	presence or absence of those terms. The dictionary can consist of either textual entries or binary entries.
- *ValidateXml*: Validation XML Content against an XML Schema; routes FlowFile based on whether or not the Content of the FlowFile
	is valid according to the user-defined XML Schema.

=== Database Access
- *ConvertJSONToSQL*: Convert a JSON document into a SQL INSERT or UPDATE command that can then be passed to the PutSQL Processor
- *ExecuteSQL*: Executes a user-defined SQL SELECT command, writing the results to a FlowFile in Avro format
- *PutSQL*: Updates a database by executing the SQL DDM statement defined by the FlowFile's content
- *SelectHiveQL*: Executes a user-defined HiveQL SELECT command against an Apache Hive database, writing the results to a FlowFile in Avro or CSV format
- *PutHiveQL*: Updates a Hive database by executing the HiveQL DDM statement defined by the FlowFile's content

[[AttributeExtraction]]
=== Attribute Extraction
- *EvaluateJsonPath*: User supplies JSONPath Expressions (Similar to XPath, which is used for XML parsing/extraction), and these Expressions
  are then evaluated against the JSON Content to either replace the FlowFile Content or extract the value into the user-named Attribute.
- *EvaluateXPath*: User supplies XPath Expressions, and these Expressions are then evaluated against the XML Content to either
  replace the FlowFile Content or extract the value into the user-named Attribute.
- *EvaluateXQuery*: User supplies an XQuery query, and this query is then evaluated against the XML Content to either replace the FlowFile
  Content or extract the value into the user-named Attribute.
- *ExtractText*: User supplies one or more Regular Expressions that are then evaluated against the textual content of the FlowFile, and the
  values that are extracted are then added as user-named Attributes.
- *HashAttribute*: Performs a hashing function against the concatenation of a user-defined list of existing Attributes.
- *HashContent*: Performs a hashing function against the content of a FlowFile and adds the hash value as an Attribute.
- *IdentifyMimeType*: Evaluates the content of a FlowFile in order to determine what type of file the FlowFile encapsulates. This Processor is
  capable of detecting many different MIME Types, such as images, word processor documents, text, and compression formats just to name
	a few.
- *UpdateAttribute*: Adds or updates any number of user-defined Attributes to a FlowFile. This is useful for adding statically configured values,
  as well as deriving Attribute values dynamically by using the Expression Language. This processor also provides an ""Advanced User Interface,""
	allowing users to update Attributes conditionally, based on user-supplied rules.

=== System Interaction
- *ExecuteProcess*: Runs the user-defined Operating System command. The Process's StdOut is redirected such that the content that is written
  to StdOut becomes the content of the outbound FlowFile. This Processor is a Source Processor - its output is expected to generate a new FlowFile,
	and the system call is expected to receive no input. In order to provide input to the process, use the ExecuteStreamCommand Processor.

- *ExecuteStreamCommand*: Runs the user-defined Operating System command. The contents of the FlowFile are optionally streamed to the StdIn
  of the process. The content that is written to StdOut becomes the content of hte outbound FlowFile. This Processor cannot be used a Source Processor -
	it must be fed incoming FlowFiles in order to perform its work. To perform the same type of functionality with a Source Processor, see the
	ExecuteProcess Processor.

=== Data Ingestion
- *GetFile*: Streams the contents of a file from a local disk (or network-attached disk) into NiFi and then deletes the original file. This
  Processor is expected to move the file from one location to another location and is not to be used for copying the data.
- *GetFTP*: Downloads the contents of a remote file via FTP into NiFi and then deletes the original file. This Processor is expected to move
  the data from one location to another location and is not to be used for copying the data.
- *GetSFTP*: Downloads the contents of a remote file via SFTP into NiFi and then deletes the original file. This Processor is expected to move
  the data from one location to another location and is not to be used for copying the data.
- *GetJMSQueue*: Downloads a message from a JMS Queue and creates a FlowFile based on the contents of the JMS message. The JMS Properties are
  optionally copied over as Attributes, as well.
- *GetJMSTopic*: Downloads a message from a JMS Topic and creates a FlowFile based on the contents of the JMS message. The JMS Properties are
  optionally copied over as Attributes, as well. This Processor supports both durable and non-durable subscriptions.
- *GetHTTP*: Downloads the contents of a remote HTTP- or HTTPS-based URL into NiFi. The Processor will remember the ETag and Last-Modified Date
  in order to ensure that the data is not continually ingested.
- *ListenHTTP*: Starts an HTTP (or HTTPS) Server and listens for incoming connections. For any incoming POST request, the contents of the request
  are written out as a FlowFile, and a 200 response is returned.
- *ListenUDP*: Listens for incoming UDP packets and creates a FlowFile per packet or per bundle of packets (depending on configuration) and
  emits the FlowFile to the 'success' relationship.
- *GetHDFS*: Monitors a user-specified directory in HDFS. Whenever a new file enters HDFS, it is copied into NiFi and deleted from HDFS. This
  Processor is expected to move the file from one location to another location and is not to be used for copying the data. This Processor is also
	expected to be run On Primary Node only, if run within a cluster. In order to copy the data from HDFS and leave it in-tact, or to stream the data
	from multiple nodes in the cluster, see the ListHDFS Processor.
- *ListHDFS* / *FetchHDFS*: ListHDFS monitors a user-specified directory in HDFS and emits a FlowFile containing the filename for each file that it
  encounters. It then persists this state across the entire NiFi cluster by way of a Distributed Cache. These FlowFiles can then be fanned out across
	the cluster and sent to the FetchHDFS Processor, which is responsible for fetching the actual content of those files and emitting FlowFiles that contain
	the content fetched from HDFS.
- *FetchS3Object*: Fetches the contents of an object from the Amazon Web Services (AWS) Simple Storage Service (S3). The outbound FlowFile contains the contents
  received from S3.
- *GetKafka*: Fetches messages from Apache Kafka, specifically for 0.8.x versions. The messages can be emitted as a FlowFile per message or can be batched together using a user-specified delimiter.
- *GetMongo*: Executes a user-specified query against MongoDB and writes the contents to a new FlowFile.
- *GetTwitter*: Allows Users to register a filter to listen to the Twitter ""garden hose"" or Enterprise endpoint, creating a FlowFile for each tweet
  that is received.

=== Data Egress / Sending Data
- *PutEmail*: Sends an E-mail to the configured recipients. The content of the FlowFile is optionally sent as an attachment.
- *PutFile*: Writes the contents of a FlowFile to a directory on the local (or network attached) file system.
- *PutFTP*: Copies the contents of a FlowFile to a remote FTP Server.
- *PutSFTP*: Copies the contents of a FlowFile to a remote SFTP Server.
- *PutJMS*: Sends the contents of a FlowFile as a JMS message to a JMS broker, optionally adding JMS Properties based on Attributes.
- *PutSQL*: Executes the contents of a FlowFile as a SQL DDL Statement (INSERT, UPDATE, or DELETE). The contents of the FlowFile must be a valid
  SQL statement. Attributes can be used as parameters so that the contents of the FlowFile can be parameterized SQL statements in order to avoid
	SQL injection attacks.
- *PutKafka*: Sends the contents of a FlowFile as a message to Apache Kafka, specifically for 0.8.x versions. The FlowFile can be sent as a single message or a delimiter, such as a
  new-line can be specified, in order to send many messages for a single FlowFile.
- *PutMongo*: Sends the contents of a FlowFile to Mongo as an INSERT or an UPDATE.

=== Splitting and Aggregation
- *SplitText*: SplitText takes in a single FlowFile whose contents are textual and splits it into 1 or more FlowFiles based on the configured
  number of lines. For example, the Processor can be configured to split a FlowFile into many FlowFiles, each of which is only 1 line.
- *SplitJson*: Allows the user to split a JSON object that is comprised of an array or many child objects into a FlowFile per JSON element.
- *SplitXml*: Allows the user to split an XML message into many FlowFiles, each containing a segment of the original. This is generally used when
  several XML elements have been joined together with a ""wrapper"" element. This Processor then allows those elements to be split out into individual
	XML elements.
- *UnpackContent*: Unpacks different types of archive formats, such as ZIP and TAR. Each file within the archive is then transferred as a single
  FlowFile.
- *MergeContent*: This Processor is responsible for merging many FlowFiles into a single FlowFile. The FlowFiles can be merged by concatenating their
  content together along with optional header, footer, and demarcator, or by specifying an archive format, such as ZIP or TAR. FlowFiles can be binned
	together based on a common attribute, or can be ""defragmented"" if they were split apart by some other Splitting process. The minimum and maximum
	size of each bin is user-specified, based on number of elements or total size of FlowFiles' contents, and an optional Timeout can be assigned as well
	so that FlowFiles will only wait for their bin to become full for a certain amount of time.
- *SegmentContent*: Segments a FlowFile into potentially many smaller FlowFiles based on some configured data size. The splitting is not performed
  against any sort of demarcator but rather just based on byte offsets. This is used before transmitting FlowFiles in order to provide lower latency
	by sending many different pieces in parallel. On the other side, these FlowFiles can then be reassembled by the MergeContent processor using the
	Defragment mode.
- *SplitContent*: Splits a single FlowFile into potentially many FlowFiles, similarly to SegmentContent. However, with SplitContent, the splitting
  is not performed on arbitrary byte boundaries but rather a byte sequence is specified on which to split the content.

=== HTTP
- *GetHTTP*: Downloads the contents of a remote HTTP- or HTTPS-based URL into NiFi. The Processor will remember the ETag and Last-Modified Date
  in order to ensure that the data is not continually ingested.
- *ListenHTTP*: Starts an HTTP (or HTTPS) Server and listens for incoming connections. For any incoming POST request, the contents of the request
  are written out as a FlowFile, and a 200 response is returned.
- *InvokeHTTP*: Performs an HTTP Request that is configured by the user. This Processor is much more versatile than the GetHTTP and PostHTTP
  but requires a bit more configuration. This Processor cannot be used as a Source Processor and is required to have incoming FlowFiles in order
	to be triggered to perform its task.
- *PostHTTP*: Performs an HTTP POST request, sending the contents of the FlowFile as the body of the message. This is often used in conjunction
  with ListenHTTP in order to transfer data between two different instances of NiFi in cases where Site-to-Site cannot be used (for instance,
	when the nodes cannot access each other directly and are able to communicate through an HTTP proxy).
	*Note*: HTTP is available as a link:user-guide.html#site-to-site[Site-to-Site] transport protocol in addition to the existing RAW socket transport. It also supports HTTP Proxy. Using HTTP Site-to-Site is recommended since it's more scalable, and can provide bi-directional data transfer using input/output ports with better user authentication and authorization.
- *HandleHttpRequest* / *HandleHttpResponse*: The HandleHttpRequest Processor is a Source Processor that starts an embedded HTTP(S) server
  similarly to ListenHTTP. However, it does not send a response to the client. Instead, the FlowFile is sent out with the body of the HTTP request
	as its contents and attributes for all of the typical Servlet parameters, headers, etc. as Attributes. The HandleHttpResponse then is able to
	send a response back to the client after the FlowFile has finished being processed. These Processors are always expected to be used in conjunction
	with one another and allow the user to visually create a Web Service within NiFi. This is particularly useful for adding a front-end to a non-web-
  based protocol or to add a simple web service around some functionality that is already performed by NiFi, such as data format conversion.

=== Amazon Web Services
- *FetchS3Object*: Fetches the content of an object stored in Amazon Simple Storage Service (S3). The content that is retrieved from S3
  is then written to the content of the FlowFile.
- *PutS3Object*: Writes the contents of a FlowFile to an Amazon S3 object using the configured credentials, key, and bucket name.
- *PutSNS*: Sends the contents of a FlowFile as a notification to the Amazon Simple Notification Service (SNS).
- *GetSQS*: Pulls a message from the Amazon Simple Queuing Service (SQS) and writes the contents of the message to the content of the FlowFile.
- *PutSQS*: Sends the contents of a FlowFile as a message to the Amazon Simple Queuing Service (SQS).
- *DeleteSQS*: Deletes a message from the Amazon Simple Queuing Service (SQS). This can be used in conjunction with the GetSQS in order to receive
  a message from SQS, perform some processing on it, and then delete the object from the queue only after it has successfully completed processing.


== Working With Attributes
Each FlowFile is created with several Attributes, and these Attributes will change over the life of
the FlowFile. The concept of a FlowFile is extremely powerful and provides three primary benefits.
First, it allows the user to make routing decisions in the flow so that FlowFiles that meet some criteria
can be handled differently than other FlowFiles. This is done using the RouteOnAttribute and similar Processors.

Secondly, Attributes are used in order to configure Processors in such a way that the configuration of the
Processor is dependent on the data itself. For instance, the PutFile Processor is able to use the Attributes in order
to know where to store each FlowFile, while the directory and filename Attributes may be different for each FlowFile.

Finally, the Attributes provide extremely valuable context about the data. This is useful when reviewing the Provenance
data for a FlowFile. This allows the user to search for Provenance data that match specific criteria, and it also allows
the user to view this context when inspecting the details of a Provenance Event. By doing this, the user is then able
to gain valuable insight as to why the data was processed one way or another, simply by glancing at this context that is
carried along with the content.

=== Common Attributes

Each FlowFile has a minimum set of Attributes:

	- *filename*: A filename that can be used to store the data to a local or remote file system.
	- *path*: The name of a directory that can be used to store the data to a local or remote file system.
	- *uuid*: A Universally Unique Identifier that distinguishes the FlowFile from other FlowFiles in the system.
	- *entryDate*: The date and time at which the FlowFile entered the system (i.e., was created). The value of this
		attribute is a number that represents the number of milliseconds since midnight, Jan. 1, 1970 (UTC).
	- *lineageStartDate*: Any time that a FlowFile is cloned, merged, or split, this results in a ""child"" FlowFile being
		created. As those children are then cloned, merged, or split, a chain of ancestors is built. This value represents
		the date and time at which the oldest ancestor entered the system. Another way to think about this is that this
		attribute represents the latency of the FlowFile through the system. The value is a number that represents the number
		of milliseconds since midnight, Jan. 1, 1970 (UTC).
	- *fileSize*: This attribute represents the number of bytes taken up by the FlowFile's Content.

Note that the `uuid`, `entryDate`, `lineageStartDate`, and `fileSize` attributes are system-generated and cannot be changed.

=== Extracting Attributes

NiFi provides several different Processors out of the box for extracting Attributes from FlowFiles. A list of commonly used
Processors for this purpose can be found above in the <<AttributeExtraction>> section. This is a very common use case for building
custom Processors, as well. Many Processors are written to understand a specific data format and extract pertinent information from
a FlowFile's content, creating Attributes to hold that information, so that decisions can then be made about how to route or
process the data.

=== Adding User-Defined Attributes

In addition to having Processors that are able to extract particular pieces of information from FlowFile content into Attributes,
it is also common for users to want to add their own user-defined Attributes to each FlowFile at a particular place in the flow.
The UpdateAttribute Processor is designed specifically for this purpose. Users are able to add a new property to the Processor
in the Configure dialog by clicking the ""+"" button in the top-right corner of the Properties tab. The user is then
prompted to enter the name of the property and then a value. For each FlowFile that is processed by this UpdateAttribute
Processor, an Attribute will be added for each user-defined property. The name of the Attribute will be the same as the name of
the property that was added. The value of the Attribute will be the same as the value of the property.

The value of the property may contain the Expression Language, as well. This allows Attributes to be modified or added
based on other Attributes. For example, if we want to prepend the hostname that is processing a file as well as the date to
a filename, we could do this by adding a property with the name `filename` and the value `${hostname()}-${now():format('yyyy-dd-MM')}-${filename}`.
While this may seem confusing at first, the section below on <<ExpressionLanguage>> will help to clear up what is going on
here.

In addition to always adding a defined set of Attributes, the UpdateAttribute Processor has an Advanced UI that allows the user
to configure a set of rules for which Attributes should be added when. To access this capability, in the Configure dialog's
Properties tab, click the `Advanced` button at the bottom of the dialog. This will provide a UI that is tailored specifically
to this Processor, rather than the simple Properties table that is provided for all Processors. Within this UI, the user is able
to configure a rules engine, essentially, specifying rules that must match in order to have the configured Attributes added
to the FlowFile.

=== Routing on Attributes

One of the most powerful features of NiFi is the ability to route FlowFiles based on their Attributes. The primary mechanism
for doing this is the RouteOnAttribute Processor. This Processor, like UpdateAttribute, is configured by adding user-defined properties.
Any number of properties can be added by clicking the ""+"" button in the top-right corner of the Properties tab in the
Processor's Configure dialog.

Each FlowFile's Attributes will be compared against the configured properties to determine whether or not the FlowFile meets the
specified criteria. The value of each property is expected to be an Expression Language expression and return a boolean value.
For more on the Expression Language, see the <<ExpressionLanguage>> section below.

After evaluating the Expression Language expressions provided against the FlowFile's Attributes, the Processor determines how to
route the FlowFile based on the Routing Strategy selected. The most common strategy is the ""Route to Property name"" strategy. With this
strategy selected, the Processor will expose a Relationship for each property configured. If the FlowFile's Attributes satisfy the given
expression, a copy of the FlowFile will be routed to the corresponding Relationship. For example, if we had a new property with the name
""begins-with-r"" and the value ""${filename:startsWith(\\'r')}"" then any FlowFile whose filename starts with the letter 'r' will be routed
to that Relationship. All other FlowFiles will be routed to 'unmatched'.


[[ExpressionLanguage]]
=== Expression Language / Using Attributes in Property Values

As we extract Attributes from FlowFiles' contents and add user-defined Attributes, they don't do us much good as an operator unless
we have some mechanism by which we can use them. The NiFi Expression Language allows us to access and manipulate FlowFile Attribute
values as we configure our flows. Not all Processor properties allow the Expression Language to be used, but many do. In order to
determine whether or not a property supports the Expression Language, a user can hover over the Help icon (
image:iconInfo.png[""Help""]
) in the Properties tab of the Processor Configure dialog. This will provide a tooltip that shows a description of the property, the
default value, if any, and whether or not the property supports the Expression Language.

For properties that do support the Expression Language, it is used by adding an expression within the opening `${` tag and the closing
`}` tag. An expression can be as simple as an attribute name. For example, to reference the `uuid` Attribute, we can simply use the
value `${uuid}`. If the Attribute name begins with any character other than a letter, or if it contains a character other than
a number, a letter, a period (.), or an underscore (_), the Attribute name will need to be quoted. For example, `${My Attribute Name}`
will be invalid, but `${'My Attribute Name'}` will refer to the Attribute `My Attribute Name`.

In addition to referencing Attribute values, we can perform a number of functions and comparisons on those Attributes. For example,
if we want to check if the `filename` attribute contains the letter 'r' without paying attention to case (upper case or lower case),
we can do this by using the expression `${filename:toLower():contains('r')}`. Note here that the functions are separated by colons.
We can chain together any number of functions to build up more complex expressions. It is also important to understand here that even
though we are calling `filename:toLower()`, this does not alter the value of the `filename` Attribute in anyway but rather just gives
us a new value to work with.

We can also embed one expression within another. For example, if we wanted to compare the value of the `attr1` Attribute to
the value of the `attr2` Attribute, we can do this with the following expression: `${attr1:equals( ${attr2} )}`.

The Expression Language contains many different functions that can be used in order to perform the tasks needed for routing and manipulating
Attributes. Functions exist for parsing and manipulating strings, comparing string and numeric values, manipulating and replacing values,
and comparing values. A full explanation of the different functions available is out of the scope of this document, but the
link:expression-language-guide.html[Expression Language Guide] provides far greater detail for each of the functions.

In addition, this Expression Language guide is built in to the application so that users are able to easily see which functions are available
and see their documentation while typing. When setting the value of a property that supports the Expression Language, if the cursor is within
the Expression Language start and end tags, pressing Ctrl + Space on the keyword will provide a pop-up of all of the available functions and
will provide auto-complete functionality. Clicking on or using the keyboard to navigate to one of the functions listed in the pop-up will
cause a tooltip to show, which explains what the function does, the arguments that it expects, and the return type of the function.



== Custom Properties Within Expression Language

In addition to using FlowFile attributes, you can also define custom properties for Expression Language use. Defining custom properties gives you additional flexibility in processing and configuring dataflows. For example, you can refer to custom properties for connection, server, and service properties. Once you have created custom properties, you can identify their location in the `nifi.variable.registry.properties` field in the 'nifi.properties' file. After you have updated the 'nifi.properties' file and restarted NiFi, you are able to use custom properties as needed.


== Working With Templates

As we use Processors to build more and more complex dataflows in NiFi, we often will find that we string together the same sequence
of Processors to perform some task. This can become tedious and inefficient. To address this, NiFi provides a concept of Templates.
A template can be thought of as a reusable sub-flow. To create a template, follow these steps:

- Select the components to include in the template. We can select multiple components by clicking on the first component and then holding
  the Shift key while selecting additional components (to include the Connections between those components), or by holding the Shift key
	while dragging a box around the desired components on the canvas.
- Select the Create Template Icon (
	image:iconNewTemplate.png[New Template Icon]
	) from the Operate palette.
- Provide a name and optionally a description for the template.
- Click the `Create` button.

Once we have created a template, we can now use it as a building block in our flow, just as we would a Processor. To do this, we will
click and drag the Template icon (
	image:iconTemplate.png[Template]
	) from the Component toolbar onto our canvas. We can then choose the template that we would like to add
to our canvas and click the `Add` button.

Finally, we have the ability to manage our templates by using the Template Management dialog. To access this dialog, select Templates
from the Global Menu. From here, we can see which templates exist and filter the templates to find the templates of interest.
On the right-hand side of the table is an icon to Export, or Download, the template as an XML file. This can then be provided to others so
that they can use your template.

To import a template into your NiFi instance, select the Upload Template icon (
	image:iconUploadTemplate.png[Upload Template]
	) from the Operator palette, click the Search Icon and navigate to the file on
your computer. Then click the `Upload` button. The template will now show up in your table, and you can drag it onto your canvas as you would
any other template that you have created.

There are a few important notes to remember when working with templates:

- Any properties that are identified as being Sensitive Properties (such as a password that is configured in a Processor) will not be added to the template. These sensitive properties will have to be populated each time that the template is added to the canvas.
- If a component that is included in the template references a Controller Service, the Controller Service will also be added to the template. This means that each time that the template is added to the graph, it will create a copy of the Controller Service.


== Monitoring NiFi

As data flows through your dataflow in NiFi, it is important to understand how well your system is performing in order to assess if you
will require more resources and in order to assess the health of your current resources. NiFi provides a few mechanisms for monitoring
your system.

=== Status Bar

Near the top of the NiFi screen under the Component toolbar is a bar that is referred to as the Status Bar. It contains a few important statistics about the current
health of NiFi. The number of Active Threads can indicate how hard NiFi is currently working, and the Queued stat indicates how many FlowFiles
are currently queued across the entire flow, as well as the total size of those FlowFiles.

If the NiFi instance is in a cluster, we will also see an indicator here telling us how many nodes are in the cluster and how many are currently
connected. In this case, the number of active threads and the queue size are indicative of all the sum of all nodes that are currently connected.

=== Component Statistics

Each Processor, Process Group, and Remote Process Group on the canvas provides several statistics about how much data has been processed
by the component. These statistics provide information about how much data has been processed in the past five minutes. This is a rolling
window and allows us to see things like the number of FlowFiles that have been consumed by a Processor, as well as the number of FlowFiles
that have been emitted by the Processor.

The connections between Processors also expose the number of items that are currently queued.

It may also be valuable to see historical values for these metrics and, if clustered, how the different nodes compare to one another.
In order to see this information, we can right-click on a component and choose the `Stats` menu item. This will show us a graph that spans
the time since NiFi was started, or up to 24 hours, whichever is less. The amount of time that is shown here can be extended or reduced
by changing the configuration in the properties file.

In the top-right corner of this dialog is a drop-down that allows the user to select which metric they are viewing. The graph on the bottom allows the
user to select a smaller portion of the graph to zoom in.


=== Bulletins

In addition to the statistics provided by each component, a user will want to know if any problems occur. While we could monitor the
logs for anything interesting, it is much more convenient to have notifications pop up on the screen. If a Processor logs
anything as a WARNING or ERROR, we will see a ""Bulletin Indicator"" show up in the top-right-hand corner of the Processor. This indicator
looks like a sticky note and will be shown for five minutes after the event occurs. Hovering over the bulletin provides information about
what happened so that the user does not have to sift through log messages to find it. If in a cluster, the bulletin will also indicate which
node in the cluster emitted the bulletin. We can also change the log level at which bulletins will occur in the Settings tab of the Configure
dialog for a Processor.

If the framework emits a bulletin, we will also see a bulletin indicator highlighted at the top-right of the screen.
In the Global Menu is a Bulletin Board option. Clicking this option will take us to the bulletin board where we can see all bulletins that occur across the NiFi instance and can filter based on the component, the message, etc.


== Data Provenance

NiFi keeps a very granular level of detail about each piece of data that it ingests. As the data is processed through
the system and is transformed, routed, split, aggregated, and distributed to other endpoints, this information is
all stored within NiFi's Provenance Repository. In order to search and view this information, we can select Data Provenance from the Global Menu. This will provide us a table that lists
the Provenance events that we have searched for:

image:provenance-table.png[Provenance Table]

Initially, this table is populated with the most recent 1,000 Provenance Events that have occurred (though it may take a few
seconds for the information to be processed after the events occur). From this dialog, there is a `Search` button that allows the
user to search for events that happened by a particular Processor, for a particular FlowFile by filename or UUID, or several other
fields. The `nifi.properties` file provides the ability to configure which of these properties are indexed, or made searchable.
Additionally, the properties file also allows you to choose specific FlowFile Attributes that will be indexed. As a result, you can
choose which Attributes will be important to your specific dataflows and make those Attributes searchable.

[[EventDetails]]
=== Event Details
Once we have performed our search, our table will be populated only with the events that match the search criteria. From here, we
can choose the Info icon (
image:iconDetails.png[Details Icon]
) on the left-hand side of the table to view the details of that event:

image:event-details.png[Event Details]

From here, we can see exactly when that event occurred, which FlowFile the event affected, which component (Processor, etc.) performed the event,
how long the event took, and the overall time that the data had been in NiFi when the event occurred (total latency).

The next tab provides a listing of all Attributes that existed on the FlowFile at the time that the event occurred:

image:event-attributes.png[Event Attributes]

From here, we can see all the Attributes that existed on the FlowFile when the event occurred, as well as the previous values for those
Attributes. This allows us to know which Attributes changed as a result of this event and how they changed. Additionally, in the right-hand
corner is a checkbox that allows the user to see only those Attributes that changed. This may not be particularly useful if the FlowFile has
only a handful of Attributes, but can be very helpful when a FlowFile has hundreds of Attributes.

This is very important because it allows the user to understand the exact context in which the FlowFile was processed. It is helpful
to understand 'why' the FlowFile was processed the way that it was, especially when the Processor was configured using the Expression Language.

Finally, we have the Content tab:

image:event-content.png[Event Content]

This tab provides us information about where in the Content Repository the FlowFile's content was stored. If the event modified the content
of the FlowFile, we will see the 'before' (input) and 'after' (output) content claims. We are then given the option to Download the content or to View the
content within NiFi itself, if the data format is one that NiFi understands how to render.

Additionally, in the Replay section of the tab, there is a 'Replay' button that allows the user to re-insert the FlowFile into the flow and re-process it from exactly the point
at which the event happened. This provides a very powerful mechanism, as we are able to modify our flow in real time, re-process a FlowFile,
and then view the results. If they are not as expected, we can modify the flow again, and re-process the FlowFile again. We are able to perform
this iterative development of the flow until it is processing the data exactly as intended.

=== Lineage Graph

In addition to viewing the details of a Provenance event, we can also view the lineage of the FlowFile involved by clicking on the Lineage Icon (
image:iconLineage.png[Lineage]
) from the table view.

This provides us with a graphical representation of exactly what happened to that piece of data as it traversed the system:

image:lineage-graph-annotated.png[Lineage Graph]

From here, we can right-click on any of the events represented and click the `View Details` menu item to see the <<EventDetails>>.
This graphical representation shows us exactly which events occurred to the data. There are a few ""special"" event types to be
aware of. If we see a JOIN, FORK, or CLONE event, we can right-click and choose to Find Parents or Expand. This allows us to
see the lineage of parent FlowFiles and children FlowFiles that were created as well.

The slider in the bottom-left corner allows us to see the time at which these events occurred. By sliding it left and right, we can
see which events introduced latency into the system so that we have a very good understanding of where in our system we may need to
provide more resources, such as the number of Concurrent Tasks for a Processor. Or it may reveal, for example, that most of the latency
was introduced by a JOIN event, in which we were waiting for more FlowFiles to join together. In either case, the ability to easily
see where this is occurring is a very powerful feature that will help users to understand how the enterprise is operating.


== Where To Go For More Information

The NiFi community has built up a significant amount of documentation on how to use the software. The following guides are available, in
addition to this Getting Started Guide:

- link:overview.html[Apache NiFi Overview] - Provides an overview of what Apache NiFi is, what it does, and why it was created.
- link:user-guide.html[Apache NiFi User Guide] - A fairly extensive guide that is often used more as a Reference Guide, as it has pretty
  lengthy discussions of all of the different components that comprise the application. This guide is written with the NiFi Operator as its
	audience. It provides information on each of the different components available in NiFi and explains how to use the different features
	provided by the application.
- link:administration-guide.html[Administration Guide] - A guide for setting up and administering Apache NiFi for production environments.
  This guide provides information about the different system-level settings, such as setting up clusters of NiFi and securing access to the
	web UI and data.
- link:expression-language-guide.html[Expression Language Guide] - A far more exhaustive guide for understanding the Expression Language than
  is provided above. This guide is the definitive documentation for the NiFi Expression Language. It provides an introduction to the EL
	and an explanation of each function, its arguments, and return types as well as providing examples.
- link:developer-guide.html[Developer's Guide] - While not an exhaustive guide to All Things NiFi Development, this guide does provide a
  comprehensive overview of the different API's available and how they should be used. In addition, it provides Best Practices for developing
	NiFi components and common Processor idioms to help aid in understanding the logic behind many of the existing NiFi components.
- link:https://cwiki.apache.org/confluence/display/NIFI/Contributor+Guide[Contributor's Guide] - A guide for explaining how to contribute
  work back to the Apache NiFi community so that others can make use of it.

Several blog postings have also been added to the Apache NiFi blog site:
link:https://blogs.apache.org/nifi/[https://blogs.apache.org/nifi/]

In addition to the blog and guides provided here, you can browse the different
link:https://nifi.apache.org/mailing_lists.html[NiFi Mailing Lists] or send an e-mail to one of the mailing lists at
link:mailto:users@nifi.apache.org[users@nifi.apache.org] or
link:mailto:dev@nifi.apache.org[dev@nifi.apache.org].

Many of the members of the NiFi community are also available on Twitter and actively monitor for tweets that mention @apachenifi.
",12336,False,2067.6066014897233,median
"[[netty4-component]]
== Netty4 Component

*Available as of Camel version 2.14*

The *netty4* 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-netty4</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]
----
netty4:tcp://0.0.0.0:99999[?options]
netty4: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 Netty4 component supports 6 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *maximumPoolSize* (advanced) | The thread pool size for the EventExecutorGroup if its in use. The default value is 16. | 16 | int
| *configuration* (advanced) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *executorService* (advanced) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *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 Netty4 endpoint is configured using URI syntax:

----
netty4:protocol:host:port
----

with the following path and query parameters:

==== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


==== Query Parameters (72 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this operation to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrap Factory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. | WARN | LoggingLevel
| *serverClosedChannel ExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. | DEBUG | LoggingLevel
| *serverExceptionCaughtLog Level* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializer Factory
| *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
| *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 |  | ClientInitializer Factory
| *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. |  | NettyCamelState CorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictable Idle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *bootstrapConfiguration* (advanced) | To use a custom configured NettyServerBootstrapConfiguration for configuring this endpoint. |  | NettyServerBootstrap Configuration
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads x 2. User can use this operation to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoder* (codec) | *Deprecated* A custom ChannelHandler class that can be used to perform special marshalling of inbound payloads. |  | ChannelHandler
| *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. |  | String
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. | LINE | TextLineDelimiter
| *encoder* (codec) | *Deprecated* A custom ChannelHandler class that can be used to perform special marshalling of outbound payloads. |  | ChannelHandler
| *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. |  | String
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END
// spring-boot-auto-configure options: START
=== Spring Boot Auto-Configuration


The component supports 78 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.netty4.configuration.allow-default-codec* | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | Boolean
| *camel.component.netty4.configuration.allow-serialized-headers* | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | Boolean
| *camel.component.netty4.configuration.auto-append-delimiter* | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | Boolean
| *camel.component.netty4.configuration.backlog* | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | Integer
| *camel.component.netty4.configuration.boss-count* | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this operation to override the default bossCount from Netty | 1 | Integer
| *camel.component.netty4.configuration.boss-group* | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *camel.component.netty4.configuration.broadcast* | Setting to choose Multicast over UDP | false | Boolean
| *camel.component.netty4.configuration.channel-group* | To use a explicit ChannelGroup. |  | ChannelGroup
| *camel.component.netty4.configuration.client-initializer-factory* | To use a custom ClientInitializerFactory |  | ClientInitializer Factory
| *camel.component.netty4.configuration.client-mode* | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | Boolean
| *camel.component.netty4.configuration.connect-timeout* | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | Integer
| *camel.component.netty4.configuration.correlation-manager* | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. 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. |  | NettyCamelState CorrelationManager
| *camel.component.netty4.configuration.decoder-max-line-length* | The max line length to use for the textline codec. | 1024 | Integer
| *camel.component.netty4.configuration.decoders* | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *camel.component.netty4.configuration.delimiter* | The delimiter to use for the textline codec. Possible values are LINE and NULL. |  | TextLineDelimiter
| *camel.component.netty4.configuration.disconnect* | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | Boolean
| *camel.component.netty4.configuration.disconnect-on-no-reply* | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | Boolean
| *camel.component.netty4.configuration.enabled-protocols* | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *camel.component.netty4.configuration.encoders* | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *camel.component.netty4.configuration.encoding* | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *camel.component.netty4.configuration.host* | 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
| *camel.component.netty4.configuration.keep-alive* | Setting to ensure socket is not closed due to inactivity | true | Boolean
| *camel.component.netty4.configuration.key-store-format* | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *camel.component.netty4.configuration.key-store-resource* | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *camel.component.netty4.configuration.lazy-channel-creation* | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | Boolean
| *camel.component.netty4.configuration.native-transport* | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: http://netty.io/wiki/native-transports.html | false | Boolean
| *camel.component.netty4.configuration.need-client-auth* | Configures whether the server needs client authentication when using SSL. | false | Boolean
| *camel.component.netty4.configuration.netty-server-bootstrap-factory* | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrap Factory
| *camel.component.netty4.configuration.network-interface* | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *camel.component.netty4.configuration.no-reply-log-level* | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. |  | LoggingLevel
| *camel.component.netty4.configuration.options* | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *camel.component.netty4.configuration.passphrase* | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *camel.component.netty4.configuration.port* | The host port number |  | Integer
| *camel.component.netty4.configuration.producer-pool-enabled* | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | Boolean
| *camel.component.netty4.configuration.producer-pool-max-active* | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | Integer
| *camel.component.netty4.configuration.producer-pool-max-idle* | Sets the cap on the number of idle instances in the pool. | 100 | Integer
| *camel.component.netty4.configuration.producer-pool-min-evictable-idle* | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | Long
| *camel.component.netty4.configuration.producer-pool-min-idle* | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | Integer
| *camel.component.netty4.configuration.protocol* | The protocol to use which can be tcp or udp. |  | String
| *camel.component.netty4.configuration.receive-buffer-size* | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | Integer
| *camel.component.netty4.configuration.receive-buffer-size-predictor* | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | Integer
| *camel.component.netty4.configuration.reconnect* | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | Boolean
| *camel.component.netty4.configuration.reconnect-interval* | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | Integer
| *camel.component.netty4.configuration.request-timeout* | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | Long
| *camel.component.netty4.configuration.reuse-address* | Setting to facilitate socket multiplexing | true | Boolean
| *camel.component.netty4.configuration.reuse-channel* | 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
| *camel.component.netty4.configuration.security-provider* | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *camel.component.netty4.configuration.send-buffer-size* | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | Integer
| *camel.component.netty4.configuration.server-closed-channel-exception-caught-log-level* | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. |  | LoggingLevel
| *camel.component.netty4.configuration.server-exception-caught-log-level* | If the server (NettyConsumer) catches an exception then its logged using this logging level. |  | LoggingLevel
| *camel.component.netty4.configuration.server-initializer-factory* | To use a custom ServerInitializerFactory |  | ServerInitializer Factory
| *camel.component.netty4.configuration.ssl* | Setting to specify whether SSL encryption is applied to this endpoint | false | Boolean
| *camel.component.netty4.configuration.ssl-client-cert-headers* | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | Boolean
| *camel.component.netty4.configuration.ssl-context-parameters* | To configure security using SSLContextParameters |  | SSLContextParameters
| *camel.component.netty4.configuration.ssl-handler* | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *camel.component.netty4.configuration.sync* | Setting to set endpoint as one-way or request-response | true | Boolean
| *camel.component.netty4.configuration.tcp-no-delay* | Setting to improve TCP protocol performance | true | Boolean
| *camel.component.netty4.configuration.textline* | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP. | false | Boolean
| *camel.component.netty4.configuration.transfer-exchange* | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | Boolean
| *camel.component.netty4.configuration.trust-store-resource* | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *camel.component.netty4.configuration.udp-byte-array-codec* | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | Boolean
| *camel.component.netty4.configuration.udp-connectionless-sending* | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | Boolean
| *camel.component.netty4.configuration.use-byte-buf* | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | Boolean
| *camel.component.netty4.configuration.using-executor-service* | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | Boolean
| *camel.component.netty4.configuration.worker-count* | When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads x 2. User can use this operation to override the default workerCount from Netty. |  | Integer
| *camel.component.netty4.configuration.worker-group* | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *camel.component.netty4.enabled* | Enable netty4 component | true | Boolean
| *camel.component.netty4.executor-service* | To use the given EventExecutorGroup. The option is a io.netty.util.concurrent.EventExecutorGroup type. |  | String
| *camel.component.netty4.maximum-pool-size* | The thread pool size for the EventExecutorGroup if its in use. The default value is 16. | 16 | Integer
| *camel.component.netty4.resolve-property-placeholders* | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | Boolean
| *camel.component.netty4.ssl-context-parameters* | To configure security using SSLContextParameters. The option is a org.apache.camel.util.jsse.SSLContextParameters type. |  | String
| *camel.component.netty4.use-global-ssl-context-parameters* | Enable usage of global SSL context parameters. | false | Boolean
| *camel.component.netty4.configuration.client-pipeline-factory* | @deprecated use #setClientInitializerFactory |  | ClientInitializer Factory
| *camel.component.netty4.configuration.decoder* | A custom ChannelHandler class that can be used to perform special marshalling of inbound payloads. |  | ChannelHandler
| *camel.component.netty4.configuration.encoder* | A custom ChannelHandler class that can be used to perform special marshalling of outbound payloads. |  | ChannelHandler
| *camel.component.netty4.configuration.key-store-file* | Client side certificate keystore to be used for encryption |  | File
| *camel.component.netty4.configuration.server-pipeline-factory* | @deprecated use #setServerInitializerFactory |  | ServerInitializer Factory
| *camel.component.netty4.configuration.trust-store-file* | Server side certificate keystore to be used for encryption |  | File
|===
// spring-boot-auto-configure options: END



=== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |*Camel 2.11.1:* 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` |*Camel 2.11.1:* Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

NOTE: Read below about using non shareable encoders/decoders.

==== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

=== Sending Messages to/from a Netty endpoint

==== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

==== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

=== Examples

==== A UDP Netty endpoint using Request-Reply and serialized object payload

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty4:udp://0.0.0.0:5155?sync=true"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           poetry.setPoet(""Dr. Sarojini Naidu"");
           exchange.getOut().setBody(poetry);
         }
       }
    }
};
----

==== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty4:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

==== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty4-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

As of Camel 2.9, the Netty component supports SSL/TLS configuration
through the link:camel-configuration-utilities.html[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.

[[Netty4-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(""netty4"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty4-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=""netty4:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty4-UsingBasicSSL/TLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
JndiRegistry registry = new JndiRegistry(createJndiContext());
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.createRegistry(registry);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty4: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);
          }
       }
  }
});
----

[[Netty4-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
<<netty4-component,Netty4>> 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.netty4.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.netty4.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(""netty4:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");
                
 from(""netty4: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=""netty4:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty4: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(""netty4: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);
        }
    }
});
----

[[Netty4-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
(JNDIRegistry, 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 =
         ""netty4: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.netty4.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty4.NettyClientBossPoolBuilder` for the
Netty producers.

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the
https://cwiki.apache.org/confluence/pages/createpage.action?spaceKey=CAMEL&title=URI&linkCreation=true&fromPageId=45877614[URI]
as shown below:

[source,xml]
----
<route>
  <from uri=""netty4: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=""netty4: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.

=== See Also

* <<netty-http-component,Netty HTTP>>
* <<mina2-component,MINA>>
",12483,False,2342.767174550025,median
"= CORPORATE BYLAWS FREIGHTTRUST AND CLEARING, INC.

....

@version 2020.01.20
@author FreightTrust & Clearing Corporation
....

== ARTICLE I

== CORPORATE OFFICES

*1.1.Offices*

----
In addition to the corporation's registered office set forth in the certificate of incorporation, the Board of
Directors may at any time establish other offices at any place or places where the corporation is qualified to do
business.
----

== ARTICLE II

== MEETINGS OF STOCKHOLDERS

*2.1.Place Of Meetings*

----
Meetings of stockholders shall be held at any place, within or outside the state of Delaware, designated by
the Board of Directors. In the absence of any such designation, stockholders' meetings shall be held at the
registered office of the corporation.
----

*2.2.Annual Meeting*

----
The annual meeting of stockholders shall be held on such date, time and place, either within or without the
state of Delaware, as may be designated by resolution of the Board of Directors each year. At the meeting,
directors shall be elected and any other proper business may be transacted.
----

*2.3.Special Meeting*

----
A special meeting of the stockholders may be called at any time by the Board of Directors, the chairperson of
the board, the chief executive officer, the president or by one or more stockholders holding shares in the aggregate
entitled to cast not less than 10% of the votes at that meeting.
----

----
If a special meeting is called by any person or persons other than the Board of Directors, the chairperson of
the board, the chief executive officer or the president, the request shall be in writing, specifying the time of such
meeting and the general nature of the business proposed to be transacted, and shall be delivered personally or sent
by registered mail or by email, fax, telegraphic or other facsimile or electronic transmission to the chairperson of
the board, the chief executive officer, the president or the secretary of the corporation. No business may be
transacted at such special meeting otherwise than specified in such notice. The officer receiving the request shall
cause notice to be promptly given to the stockholders entitled to vote, in accordance with the provisions of
Sections 2.4 and 2.5 of this Article II, that a meeting will be held at the time requested by the person or persons
calling the meeting, not less than 35 nor more than 60 days after the receipt of the request. If the notice is not
given within 20 days after the receipt of the request, the person or persons requesting the meeting may give the
notice. Nothing contained in this paragraph of this Section 2.3 shall be construed as limiting, fixing, or affecting
the time when a meeting of stockholders called by action of the Board of Directors may be held.
----

*2.4.Notice Of Stockholders' Meetings*

----
All notices of meetings with stockholders shall be in writing and shall be sent or otherwise given in
accordance with Section 2.5 of these bylaws not less than 10 nor more than 60 days before the date of the meeting
to each stockholder entitled to vote at such meeting. The notice shall specify the place (if any), date and hour of
the meeting, and in the case of a special meeting, the purpose or purposes for which the meeting is called.
----

*2.5.Manner Of Giving Notice;
Affidavit Of Notice*

----
Written notice of any meeting of stockholders, if mailed, is given when deposited in the United States mail,
postage prepaid, directed to the stockholder at his address as it appears on the records of the corporation. Without
limiting the manner by which notice otherwise may be given effectively to stockholders, any notice to
stockholders may be given by electronic mail or other electronic transmission, in the manner provided in Section
232 of the Delaware General Corporation Law. An affidavit of the secretary or an assistant secretary or of the
transfer agent of the corporation that the notice has been given shall, in the absence of fraud, be prima facie
evidence of the facts stated therein.
----

*2.6.Quorum*

----
The holders of a majority of the shares of stock issued and outstanding and entitled to vote thereat, present in
person or represented by proxy, shall constitute a quorum at all meetings of the stockholders for the transaction of
business except as otherwise provided by statute or by the certificate of incorporation. If, however, such quorum is
not present or represented at any meeting of the stockholders, then either (a) the chairperson of the meeting or (b)
holders of a majority of the shares of stock entitled to vote who are present, in person or by proxy, shall have
power to adjourn the meeting to another place (if any), date or time.
----

*2.7.Adjourned Meeting;
Notice*

----
When a meeting is adjourned to another place (if any), date or time, unless these bylaws otherwise require,
notice need not be given of the adjourned meeting if the time and place (if any), thereof and the means of remote
communications (if any) by which stockholders and proxyholders may be deemed to be present and vote at such
adjourned meeting, are announced at the meeting at which the adjournment is taken. At the adjourned meeting the
corporation may transact any business that might have been transacted at the original meeting. If the adjournment
is for more than 30 days, or if after the adjournment a new record date is fixed for the adjourned meeting, notice
of the place (if any), date and time of the adjourned meeting and the means of remote communications (if any) by
which stockholders and proxy holders may be deemed to be present in person and vote at such adjourned meeting
shall be given to each stockholder of record entitled to vote at the meeting.
----

*2.8.Organization;
Conduct of Business*

----
Such person as the Board of Directors may have designated or, in the absence of such a person, the chief
executive officer, or in his or her absence, the president or, in his or her absence, such person as may be chosen by
the holders of a majority of the shares entitled to vote who are present, in person or by proxy, shall call to order
any meeting of the stockholders and act as chairperson of the meeting. In the absence of the secretary of the
corporation, the secretary of the meeting shall be such person as the chairperson of the meeting appoints.
----

----
The chairperson of any meeting of stockholders shall determine the order of business and the procedure at
the meeting, including the manner of voting and the conduct of business. The date and time of opening and closing
of the polls for each matter upon which the stockholders will vote at the meeting shall be announced at the
meeting.
----

*2.9.Voting*

----
The stockholders entitled to vote at any meeting of stockholders shall be determined in accordance with the
provisions of Section 2.12 of these bylaws, subject to the provisions of Sections 217 and 218 of the Delaware
General Corporation Law (relating to voting rights of fiduciaries, pledgors and joint owners of stock and to voting
trusts and other voting agreements).
----

----
Except as may be otherwise provided in the certificate of incorporation, each stockholder shall be entitled to
one vote for each share of capital stock held by such stockholder. All elections shall be determined by a plurality
of the votes cast, and except as otherwise required by law, all other matters shall be determined by a majority of
the votes cast affirmatively or negatively.
----

*2.10.Waiver Of Notice*

----
Whenever notice is required to be given under any provision of the Delaware General Corporation Law or of
the certificate of incorporation or these bylaws, a written waiver thereof, signed by the person entitled to notice, or
waiver by electronic mail or other electronic transmission by such person, whether before or after the time stated
therein, shall be deemed equivalent to notice. Attendance of a person at a meeting shall constitute a waiver of
notice of such meeting, except when the person attends a meeting for the express purpose of objecting, at the
beginning of the meeting, to the transaction of any business because the meeting is not lawfully called or
convened. Neither the business to be transacted at, nor the purpose of, any regular or special meeting of the
stockholders need be specified in any written waiver of notice, or any waiver of notice by electronic transmission,
unless so required by the certificate of incorporation or these bylaws.
----

*2.11.Stockholder Action By Written Consent Without A Meeting*

----
Unless otherwise provided in the certificate of incorporation, any action required to be taken at any annual or
special meeting of stockholders of the corporation, or any action that may be taken at any annual or special
meeting of such stockholders, may be taken without a meeting, without prior notice, and without a vote if a
consent in writing, setting forth the action so taken, is (a) signed by the holders of outstanding stock having not
less than the minimum number of votes that would be necessary to authorize or take such action at a meeting at
which all shares entitled to vote thereon were present and voted, and (b) delivered to the corporation in accordance
with Section 228(a) of the Delaware General Corporation Law.
----

----
Every written consent shall bear the date of signature of each stockholder who signs the consent and no
written consent shall be effective to take the corporate action referred to therein unless, within 60 days of the date
the earliest dated consent is delivered to the corporation, a written consent or consents signed by a sufficient
number of holders to take action are delivered to the corporation in the manner prescribed in this Section. A
telegram, cablegram, electronic mail or other electronic transmission consenting to an action to be taken and
transmitted by a stockholder or proxyholder, or by a person or persons authorized to act for a stockholder or
proxyholder, shall be deemed to be written, signed and dated for purposes of this Section to the extent permitted
by law. Any such consent shall be delivered in accordance with Section 228(d)(1) of the Delaware General
Corporation Law.
----

----
Any copy, facsimile or other reliable reproduction of a consent in writing may be substituted or used in lieu
of the original writing for any and all purposes for which the original writing could be used, provided that such
copy, facsimile or other reproduction shall be a complete reproduction of the entire original writing.
----

----
Prompt notice of the taking of the corporate action without a meeting by less than unanimous written consent
shall be given to those stockholders who have not consented in writing (including by electronic mail or other
electronic transmission as permitted by law). If the action which is consented to is such as would have required the
filing of a certificate under any section of the Delaware General Corporation Law if such action had been voted on
by stockholders at a meeting thereof, then the certificate filed under such section shall state, in lieu of any
statement required by such section concerning any vote of stockholders, that written notice and written consent
----

----
have been given as provided in Section 228 of the Delaware General Corporation Law.
----

*2.12.Record Date For Stockholder Notice;
Voting;
Giving Consents*

----
In order that the corporation may determine the stockholders entitled to notice of or to vote at any meeting of
stockholders or any adjournment thereof, or entitled to express consent to corporate action in writing without a
meeting, or entitled to receive payment of any dividend or other distribution or allotment of any rights, or entitled
to exercise any rights in respect of any change, conversion or exchange of stock or for the purpose of any other
lawful action, the Board of Directors may fix, in advance, a record date, which shall not be more than 60 nor less
than 10 days before the date of such meeting, nor more than 60 days prior to any other action.
----

----
If the Board of Directors does not so fix a record date:
a. The record date for determining stockholders entitled to notice of or to vote at a meeting of
stockholders shall be at the close of business on the day next preceding the day on which notice is given, or,
if notice is waived, at the close of business on the day next preceding the day on which the meeting is held.
----

----
b. The record date for determining stockholders entitled to consent to corporate action in writing
without a meeting, when no prior action by the Board of Directors is necessary, shall be the day on which the
first written consent (including consent by electronic mail or other electronic transmission as permitted by
law) is delivered to the corporation.
----

----
c. The record date for determining stockholders for any other purpose shall be at the close of business
on the day on which the Board of Directors adopts the resolution relating thereto.
----

----
A determination of stockholders of record entitled to notice of or to vote at a meeting of stockholders shall
apply to any adjournment of the meeting, if such adjournment is for 30 days or less; provided, however, that the
Board of Directors may fix a new record date for the adjourned meeting.
----

*2.13.Proxies*

----
Each stockholder entitled to vote at a meeting of stockholders or to express consent or dissent to corporate
action in writing without a meeting may authorize another person or persons to act for such stockholder by an
instrument in writing or by an electronic transmission permitted by law filed with the secretary of the corporation,
but no such proxy shall be voted or acted upon after three years from its date, unless the proxy provides for a
longer period. A proxy shall be deemed signed if the stockholder's name is placed on the proxy (whether by
manual signature, typewriting, facsimile, electronic or telegraphic transmission or otherwise) by the stockholder
or the stockholder's attorney-in-fact. The revocability of a proxy that states on its face that it is irrevocable shall be
governed by the provisions of Section 212(e) of the Delaware General Corporation Law.
----

== ARTICLE III

== DIRECTORS

*3.1.Powers*

----
Subject to the provisions of the Delaware General Corporation Law and any limitations in the certificate of
incorporation or these bylaws relating to action required to be approved by the stockholders or by the outstanding
shares, the business and affairs of the corporation shall be managed and all corporate powers shall be exercised by
or under the direction of the Board of Directors.
----

*3.2.Number Of Directors*

----
The number of directors constituting the entire Board of Directors is one (1). This number may be changed
----

----
by a resolution of the Board of Directors or of the stockholders, subject to Section 3.4 of these bylaws. No
reduction of the authorized number of directors shall have the effect of removing any director before such
director's term of office expires.
----

*3.3.Election, Qualification And Term Of Office Of Directors*

----
Except as provided in Section 3.4 of these bylaws, and unless otherwise provided in the certificate of
incorporation, directors shall be elected at each annual meeting of stockholders to hold office until the next annual
meeting. Directors need not be stockholders unless so required by the certificate of incorporation or these bylaws,
wherein other qualifications for directors may be prescribed. Each director, including a director elected to fill a
vacancy, shall hold office until his or her successor is elected and qualified or until his or her earlier resignation or
removal.
----

----
Unless otherwise specified in the certificate of incorporation, elections of directors need not be by written
ballot.
----

*3.4.Resignation And Vacancies*

----
Any director may resign at any time upon written notice to the attention of the Secretary of the corporation.
Notwithstanding the provisions of Section 223(a)(1) and 223(a)(2) of the Delaware General Corporation Law, any
vacancy or newly created directorship may be filled by a majority of the directors then in office (including any
directors that have tendered a resignation effective at a future date), though less than a quorum, or by a sole
remaining director, and the directors so chosen shall hold office until the next annual election and until their
successors are duly elected and shall qualify, unless sooner displaced; provided, however, that where such
vacancy or newly created directorship occurs among the directors elected by the holders of a class or series of
stock, the holders of shares of such class or series may override the Board of Directors' action to fill such vacancy
or newly created directorship by (i) voting for their own designee to fill such vacancy or newly created
directorship at a meeting of the corporation's stockholders or (ii) written consent, if the consenting stockholders
hold a sufficient number of shares to elect their designee at a meeting of the stockholders.
----

----
If at any time, by reason of death or resignation or other cause, the corporation should have no directors in
office, then any officer or any stockholder or an executor, administrator, trustee or guardian of a stockholder, or
other fiduciary entrusted with like responsibility for the person or estate of a stockholder, may call a special
meeting of stockholders in accordance with the provisions of the certificate of incorporation or these bylaws, or
may apply to the Court of Chancery for a decree summarily ordering an election as provided in Section 211 of the
Delaware General Corporation Law.
----

----
If, at the time of filling any vacancy or any newly created directorship, the directors then in office constitute
less than a majority of the whole board (as constituted immediately prior to any such increase), then the Court of
Chancery may, upon application of any stockholder or stockholders holding at least 10% of the total number of the
shares at the time outstanding having the right to vote for such directors, summarily order an election to be held to
fill any such vacancies or newly created directorships, or to replace the directors chosen by the directors then in
office as aforesaid, which election shall be governed by the provisions of Section 211 of the Delaware General
Corporation Law as far as applicable.
----

*3.5.Place Of Meetings;
Meetings By Telephone*

----
The Board of Directors of the corporation may hold meetings, both regular and special, either within or
outside the state of Delaware.
----

----
Unless otherwise restricted by the certificate of incorporation or these bylaws, members of the Board of
Directors, or any committee designated by the Board of Directors, may participate in a meeting of the Board of
Directors, or any committee, by means of conference telephone or other communications equipment by means of
which all persons participating in the meeting can hear each other, and such participation in a meeting shall
constitute presence in person at the meeting.
----

*3.6.Regular Meetings*

----
Regular meetings of the Board of Directors may be held without notice at such time and at such place as
shall from time to time be determined by the board.
----

*3.7.Special Meetings;
Notice*

----
Special meetings of the Board of Directors for any purpose or purposes may be called at any time by the
chairperson of the board, the chief executive officer, the president, the secretary or any two directors.
----

----
Notice of the time and place of special meetings shall be delivered personally or by telephone to each director
or sent by first-class mail, facsimile, electronic transmission, or telegram, charges prepaid, addressed to each
director at that director's address as it is shown on the records of the corporation. If the notice is mailed, it shall be
deposited in the United States mail at least 4 days before the time of the holding of the meeting. If the notice is
delivered personally or by facsimile, electronic transmission, telephone or telegram, it shall be delivered at least 24
hours before the time of the holding of the meeting. Any oral notice given personally or by telephone may be
communicated either to the director or to a person at the office of the director who the person giving the notice
has reason to believe will promptly communicate it to the director. The notice need not specify the purpose of the
meeting. The notice need not specify the place of the meeting, if the meeting is to be held at the principal
executive office of the corporation. Unless otherwise indicated in the notice thereof, any and all business may be
transacted at a special meeting.
----

*3.8.Quorum*

----
At all meetings of the Board of Directors, a majority of the total number of duly elected directors then in
office (but in no case less than 1/3 of the total number of authorized directors) shall constitute a quorum for the
transaction of business and the act of a majority of the directors present at any meeting at which there is a quorum
shall be the act of the Board of Directors, except as may be otherwise specifically provided by statute or by the
certificate of incorporation. If a quorum is not present at any meeting of the Board of Directors, then the directors
present thereat may adjourn the meeting from time to time, without notice other than announcement at the
meeting, until a quorum is present.
----

----
A meeting at which a quorum is initially present may continue to transact business notwithstanding the
withdrawal of directors, if any action taken is approved by at least a majority of the required quorum for that
meeting.
----

*3.9.Waiver Of Notice*

----
Whenever notice is required to be given under any provision of the Delaware General Corporation Law or of
the certificate of incorporation or these bylaws, a written waiver thereof, signed by the person entitled to notice, or
waiver by electronic mail or other electronic transmission by such person, whether before or after the time stated
therein, shall be deemed equivalent to notice. Attendance of a person at a meeting shall constitute a waiver of
notice of such meeting, except when the person attends a meeting for the express purpose of objecting, at the
beginning of the meeting, to the transaction of any business because the meeting is not lawfully called or
convened. Neither the business to be transacted at, nor the purpose of, any regular or special meeting of the
directors, or members of a committee of directors, need be specified in any written waiver of notice unless so
required by the certificate of incorporation or these bylaws.
----

*3.10.Board Action By Written Consent Without A Meeting*

----
Unless otherwise restricted by the certificate of incorporation or these bylaws, any action required or
permitted to be taken at any meeting of the Board of Directors, or of any committee thereof, may be taken without
a meeting if all members of the board or committee, as the case may be, consent thereto in writing or by electronic
----

----
transmission, and the writing or writings or electronic transmission or transmissions are filed with the minutes of
proceedings of the board or committee. Such filing shall be in paper form if the minutes are maintained in paper
form and shall be in electronic form if the minutes are maintained in electronic form.
----

----
Any copy, facsimile or other reliable reproduction of a consent in writing may be substituted or used in lieu
of the original writing for any and all purposes for which the original writing could be used, provided that such
copy, facsimile or other reproduction shall be a complete reproduction of the entire original writing.
----

*3.11.Fees And Compensation Of Directors*

----
Unless otherwise restricted by the certificate of incorporation or these bylaws, the Board of Directors shall
have the authority to fix the compensation of directors. No such compensation shall preclude any director from
serving the corporation in any other capacity and receiving compensation therefor.
----

*3.12.Approval Of Loans To Officers*

----
The corporation may lend money to, or guarantee any obligation of, or otherwise assist any officer or other
employee of the corporation or of its subsidiary, including any officer or employee who is a director of the
corporation or its subsidiary, whenever, in the judgment of the directors, such loan, guaranty or assistance may
reasonably be expected to benefit the corporation. The loan, guaranty or other assistance may be with or without
interest and may be unsecured, or secured in such manner as the Board of Directors shall approve, including,
without limitation, a pledge of shares of stock of the corporation. Nothing in this section shall be deemed to deny,
limit or restrict the powers of guaranty or warranty of the corporation at common law or under any statute.
----

*3.13.Removal Of Directors*

----
Unless otherwise restricted by statute, by the certificate of incorporation or by these bylaws, any director or
the entire Board of Directors may be removed, with or without cause, by, and only by, the affirmative vote of the
holders of the shares of the class or series of stock entitled to elect such director or directors, given either at a
special meeting of such stockholders duly called for that purpose or pursuant to a written consent of stockholders,
and any vacancy thereby created may be filled by the holders of that class or series of stock represented at the
meeting or pursuant to written consent; provided, however, that if the stockholders of the corporation are entitled
to cumulative voting, if less than the entire Board of Directors is to be removed, no director may be removed
without cause if the votes cast against his removal would be sufficient to elect him if then cumulatively voted at
an election of the entire Board of Directors.
----

----
No reduction of the authorized number of directors shall have the effect of removing any director prior to the
expiration of such director's term of office.
----

*3.14.Chairperson Of The Board Of Directors*

----
The corporation may also have, at the discretion of the Board of Directors, a chairperson of the Board of
Directors who shall not be considered an officer of the corporation.
----

== ARTICLE IV

== COMMITTEES

*4.1.Committees Of Directors*

----
The Board of Directors may designate one or more committees, each committee to consist of one or more of
the directors of the corporation. The Board may designate 1 or more directors as alternate members of any
committee, who may replace any absent or disqualified member at any meeting of the committee. In the absence
----

----
or disqualification of a member of a committee, the member or members present at any meeting and not
disqualified from voting, whether or not such member or members constitute a quorum, may unanimously appoint
another member of the Board of Directors to act at the meeting in the place of any such absent or disqualified
member. Any such committee, to the extent provided in the resolution of the Board of Directors, or in these
bylaws, shall have and may exercise all the powers and authority of the Board of Directors in the management of
the business and affairs of the corporation, and may authorize the seal of the corporation to be affixed to all papers
which may require it; but no such committee shall have the power or authority in reference to the following
matters: (i) approving or adopting, or recommending to the stockholders, any action or matter expressly required
by the General Corporate Law of Delaware to be submitted to stockholders for approval or (ii) adopting, amending
or repealing any Bylaw of the corporation.
----

*4.2.Committee Minutes*

----
Each committee shall keep regular minutes of its meetings and report the same to the Board of Directors
when required.
----

*4.3.Meetings And Action Of Committees*

----
Meetings and actions of committees shall be governed by, and held and taken in accordance with, the
provisions of Section 3.5 (place of meetings and meetings by telephone), Section 3.6 (regular meetings), Section
3.7 (special meetings and notice), Section 3.8 (quorum), Section 3.9 (waiver of notice), and Section 3.10 (action
without a meeting) of these bylaws, with such changes in the context of such provisions as are necessary to
substitute the committee and its members for the Board of Directors and its members; provided, however, that the
time of regular meetings of committees may be determined either by resolution of the Board of Directors or by
resolution of the committee, that special meetings of committees may also be called by resolution of the Board of
Directors and that notice of special meetings of committees shall also be given to all alternate members, who shall
have the right to attend all meetings of the committee. The Board of Directors may adopt rules for the government
of any committee not inconsistent with the provisions of these bylaws.
----

== ARTICLE V

== OFFICERS

*5.1.Officers*

----
The officers of the corporation shall be a president and a secretary. The corporation may also have, at the
discretion of the Board of Directors, a chief executive officer, a chief financial officer, a treasurer, one or more
vice presidents, one or more assistant secretaries, one or more assistant treasurers, and any such other officers as
may be appointed in accordance with the provisions of Section 5.3 of these bylaws. Any number of offices may be
held by the same person.
----

*5.2.Appointment Of Officers*

----
The officers of the corporation, except such officers as may be appointed in accordance with the provisions
of Sections 5.3 or 5.5 of these bylaws, shall be appointed by the Board of Directors, subject to the rights (if any) of
an officer under any contract of employment.
----

*5.3.Subordinate Officers*

----
The Board of Directors may appoint, or empower the chief executive officer or the president to appoint, such
other officers and agents as the business of the corporation may require, each of whom shall hold office for such
period, have such authority, and perform such duties as are provided in these bylaws or as the Board of Directors
may from time to time determine.
----

*5.4.Removal And Resignation Of Officers*

----
Subject to the rights (if any) of an officer under any contract of employment, any officer may be removed,
either with or without cause, by an affirmative vote of the majority of the Board of Directors at any regular or
special meeting of the board or, except in the case of an officer chosen by the Board of Directors, by any officer
upon whom the power of removal is conferred by the Board of Directors.
----

----
Any officer may resign at any time by giving written notice to the corporation. Any resignation shall take
effect at the date of the receipt of that notice or at any later time specified in that notice; and, unless otherwise
specified in that notice, the acceptance of the resignation shall not be necessary to make it effective. Any
resignation is without prejudice to the rights (if any) of the corporation under any contract to which the officer is a
party.
----

*5.5.Vacancies In Offices*

----
Any vacancy occurring in any office of the corporation shall be filled by the Board of Directors.
----

*5.6.Chief Executive Officer*

----
Subject to such supervisory powers (if any) as may be given by the Board of Directors to the chairperson of
the board (if any), the chief executive officer of the corporation (if such an officer is appointed) shall, subject to
the control of the Board of Directors, have general supervision, direction, and control of the business and the
officers of the corporation and shall have the general powers and duties of management usually vested in the
office of chief executive officer of a corporation and shall have such other powers and duties as may be prescribed
by the Board of Directors or these bylaws.
----

----
The person serving as chief executive officer shall also be the acting president of the corporation whenever
no other person is then serving in such capacity.
----

*5.7.President*

----
Subject to such supervisory powers (if any) as may be given by the Board of Directors to the chairperson of
the board (if any) or the chief executive officer, the president shall have general supervision, direction, and control
of the business and other officers of the corporation. He or she shall have the general powers and duties of
management usually vested in the office of president of a corporation and such other powers and duties as may be
prescribed by the Board of Directors or these bylaws.
----

----
The person serving as president shall also be the acting chief executive officer, secretary or treasurer of the
corporation, as applicable, whenever no other person is then serving in such capacity.
----

*5.8.Vice Presidents*

----
In the absence or disability of the chief executive officer and president, the vice presidents (if any) in order of
their rank as fixed by the Board of Directors or, if not ranked, a vice president designated by the Board of
Directors, shall perform all the duties of the president and when so acting shall have all the powers of, and be
subject to all the restrictions upon, the president. The vice presidents shall have such other powers and perform
such other duties as from time to time may be prescribed for them respectively by the Board of Directors, these
bylaws, the president or the chairperson of the board.
----

*5.9.Secretary*

----
The secretary shall keep or cause to be kept, at the principal executive office of the corporation or such other
----

----
place as the Board of Directors may direct, a book of minutes of all meetings and actions of directors, committees
of directors, and stockholders. The minutes shall show the time and place of each meeting, the names of those
present at directors' meetings or committee meetings, the number of shares present or represented at stockholders'
meetings, and the proceedings thereof.
----

----
The secretary shall keep, or cause to be kept, at the principal executive office of the corporation or at the
office of the corporation's transfer agent or registrar, as determined by resolution of the Board of Directors, a share
register, or a duplicate share register, showing the names of all stockholders and their addresses, the number and
classes of shares held by each, the number and date of certificates (if any) evidencing such shares, and the number
and date of cancellation of every certificate (if any) surrendered for cancellation.
----

----
The secretary shall give, or cause to be given, notice of all meetings of the stockholders and of the Board of
Directors required to be given by law or by these bylaws. He or she shall have such other powers and perform such
other duties as may be prescribed by the Board of Directors or by these bylaws.
----

*5.10.Chief Financial Officer*

----
The chief financial officer (if such an officer is appointed) shall keep and maintain, or cause to be kept and
maintained, adequate and correct books and records of accounts of the properties and business transactions of the
corporation, including accounts of its assets, liabilities, receipts, disbursements, gains, losses, capital, retained
earnings and shares. The books of account shall at all reasonable times be open to inspection by any member of
the Board of Directors.
----

----
The chief financial officer shall render to the chief executive officer, the president, or the Board of Directors,
upon request, an account of all his or her transactions as chief financial officer and of the financial condition of the
corporation. He or she shall have the general powers and duties usually vested in the office of chief financial
officer of a corporation and shall have such other powers and perform such other duties as may be prescribed by
the Board of Directors or these bylaws.
----

----
The person serving as the chief financial officer shall also be the acting treasurer of the corporation
whenever no other person is then serving in such capacity. Subject to such supervisory powers (if any) as may be
given by the Board of Directors to another officer of the corporation, the chief financial officer shall supervise and
direct the responsibilities of the treasurer whenever someone other than the chief financial officer is serving as
treasurer of the corporation.
----

*5.11.Treasurer*

----
The treasurer (if such an officer is appointed) shall keep and maintain, or cause to be kept and maintained,
adequate and correct books and records with respect to all bank accounts, deposit accounts, cash management
accounts and other investment accounts of the corporation. The books of account shall at all reasonable times be
open to inspection by any member of the Board of Directors.
----

----
The treasurer shall deposit, or cause to be deposited, all moneys and other valuables in the name and to the
credit of the corporation with such depositories as may be designated by the Board of Directors. He or she shall
disburse the funds of the corporation as may be ordered by the Board of Directors and shall render to the chief
financial officer, the chief executive officer, the president or the Board of Directors, upon request, an account of
all his or her transactions as treasurer. He or she shall have the general powers and duties usually vested in the
office of treasurer of a corporation and shall have such other powers and perform such other duties as may be
prescribed by the Board of Directors or these bylaws.
----

----
The person serving as the treasurer shall also be the acting chief financial officer of the corporation
whenever no other person is then serving in such capacity.
----

*5.12.Representation Of Shares Of Other Corporations*

----
The chairperson of the board, the chief executive officer, the president, any vice president, the chief financial
officer, the secretary or assistant secretary of this corporation, or any other person authorized by the Board of
Directors or the chief executive officer or the president or a vice president, is authorized to vote, represent, and
exercise on behalf of this corporation all rights incident to any and all shares of any other corporation or
corporations standing in the name of this corporation. The authority granted herein may be exercised either by
such person directly or by any other person authorized to do so by proxy or power of attorney duly executed by
the person having such authority.
----

*5.13.Authority And Duties Of Officers*

----
In addition to the foregoing authority and duties, all officers of the corporation shall respectively have such
authority and perform such duties in the management of the business of the corporation as may be designated from
time to time by the Board of Directors or the stockholders.
----

== ARTICLE VI

== INDEMNIFICATION OF DIRECTORS, OFFICERS, EMPLOYEES, AND OTHER AGENTS

*6.1.Indemnification Of Directors And Officers*

----
The corporation shall, to the maximum extent and in the manner permitted by the Delaware General
Corporation Law, indemnify each of its directors and officers against expenses (including attorneys' fees),
judgments, fines, settlements and other amounts actually and reasonably incurred in connection with any
proceeding, arising by reason of the fact that such person is or was an agent of the corporation. For purposes of
this Section 6.1, a ""director"" or ""officer"" of the corporation includes any person (a) who is or was a director or
officer of the corporation, (b) who is or was serving at the request of the corporation as a director or officer of
another corporation, partnership, joint venture, trust or other enterprise, or (c) who was a director or officer of a
corporation which was a predecessor corporation of the corporation or of another enterprise at the request of such
predecessor corporation.
----

*6.2.Indemnification Of Others*

----
The corporation shall have the power, to the maximum extent and in the manner permitted by the Delaware
General Corporation Law, to indemnify each of its employees and agents (other than directors and officers)
against expenses (including attorneys' fees), judgments, fines, settlements and other amounts actually and
reasonably incurred in connection with any proceeding, arising by reason of the fact that such person is or was an
agent of the corporation. For purposes of this Section 6.2, an ""employee"" or ""agent"" of the corporation (other than
a director or officer) includes any person (a) who is or was an employee or agent of the corporation, (b) who is or
was serving at the request of the corporation as an employee or agent of another corporation, partnership, joint
venture, trust or other enterprise, or (c) who was an employee or agent of a corporation which was a predecessor
corporation of the corporation or of another enterprise at the request of such predecessor corporation.
----

*6.3.Payment Of Expenses In Advance*

----
Expenses incurred in defending any action or proceeding for which indemnification is required pursuant to
Section 6.1 or for which indemnification is permitted pursuant to Section 6.2 following authorization thereof by
the Board of Directors shall be paid by the corporation in advance of the final disposition of such action or
proceeding upon receipt of an undertaking by or on behalf of the indemnified party to repay such amount if it shall
ultimately be determined by final judicial decision from which there is no further right to appeal that the
indemnified party is not entitled to be indemnified as authorized in this Article VI.
----

*6.4.Indemnity Not Exclusive*

----
The indemnification provided by this Article VI shall not be deemed exclusive of any other rights to which
those seeking indemnification may be entitled under any Bylaw, agreement, vote of stockholders or disinterested
directors or otherwise, both as to action in an official capacity and as to action in another capacity while holding
such office, to the extent that such additional rights to indemnification are authorized in the certificate of
incorporation.
----

*6.5.Insurance*

----
The corporation may purchase and maintain insurance on behalf of any person who is or was a director,
officer, employee or agent of the corporation, or is or was serving at the request of the corporation as a director,
officer, employee or agent of another corporation, partnership, joint venture, trust or other enterprise against any
liability asserted against him or her and incurred by him or her in any such capacity, or arising out of his or her
status as such, whether or not the corporation would have the power to indemnify him or her against such liability
under the provisions of the Delaware General Corporation Law.
----

*6.6.Conflicts*

----
No indemnification or advance shall be made under this Article VI, except where such indemnification or
advance is mandated by law or the order, judgment or decree of any court of competent jurisdiction, in any
circumstance where it appears:
----

----
(a) That it would be inconsistent with a provision of the certificate of incorporation, these bylaws, a
resolution of the stockholders or an agreement in effect at the time of the accrual of the alleged cause of the action
asserted in the proceeding in which the expenses were incurred or other amounts were paid, which prohibits or
otherwise limits indemnification; or
----

----
(b) That it would be inconsistent with any condition expressly imposed by a court in approving a settlement.
----

== ARTICLE VII

== RECORDS AND REPORTS

*7.1.Maintenance And Inspection Of Records*

----
The corporation shall, either at its principal executive offices or at such place or places as designated by the
Board of Directors, keep a record of its stockholders listing their names and addresses and the number and class of
shares held by each stockholder, a copy of these bylaws as amended to date, accounting books, and other records.
----

----
Any stockholder of record, in person or by attorney or other agent, shall, upon written demand under oath
stating the purpose thereof, have the right during the usual hours for business to inspect for any proper purpose the
corporation's stock ledger, a list of its stockholders, and its other books and records and to make copies or extracts
therefrom. A proper purpose shall mean a purpose reasonably related to such person's interest as a stockholder. In
every instance where an attorney or other agent is the person who seeks the right to inspection, the demand under
oath shall be accompanied by a power of attorney or such other writing that authorizes the attorney or other agent
to so act on behalf of the stockholder. The demand under oath shall be directed to the corporation at its registered
office in Delaware or at its principal place of business.
----

----
A complete list of stockholders entitled to vote at any meeting of stockholders, arranged in alphabetical order
for each class of stock and showing the address of each such stockholder and the number of shares registered in
each such stockholder's name, shall be open to the examination of any such stockholder for a period of at least 10
days prior to the meeting in the manner provided by law. The stock list shall also be open to the examination of
any stockholder during the whole time of the meeting as provided by law. This list shall presumptively determine
the identity of the stockholders entitled to vote at the meeting and the number of shares held by each of them.
----

*7.2.Inspection By Directors*

----
Any director shall have the right to examine the corporation's stock ledger, a list of its stockholders, and its
other books and records for a purpose reasonably related to his or her position as a director. The Court of
Chancery is hereby vested with the exclusive jurisdiction to determine whether a director is entitled to the
inspection sought. The Court may summarily order the corporation to permit the director to inspect any and all
books and records, the stock ledger, and the stock list and to make copies or extracts therefrom. The Court may, in
its discretion, prescribe any limitations or conditions with reference to the inspection, or award such other and
further relief as the Court may deem just and proper.
----

== ARTICLE VIII

== GENERAL MATTERS

*8.1.Checks*

----
From time to time, the Board of Directors shall determine by resolution which person or persons may sign or
endorse all checks, drafts, other orders for payment of money, notes or other evidences of indebtedness that are
issued in the name of or payable to the corporation, and only the persons so authorized shall sign or endorse those
instruments.
----

*8.2.Execution Of Corporate Contracts And Instruments*

----
The Board of Directors, except as otherwise provided in these bylaws, may authorize any officer or officers,
or agent or agents, to enter into any contract or execute any instrument in the name of and on behalf of the
corporation; such authority may be general or confined to specific instances. Unless so authorized or ratified by
the Board of Directors or within the agency power of an officer, no officer, agent or employee shall have any
power or authority to bind the corporation by any contract or engagement or to pledge its credit or to render it
liable for any purpose or for any amount.
----

*8.3.Stock Certificates and Notices;
Uncertificated Stock;
Partly Paid Shares*

----
The shares of the corporation may be certificated or uncertificated, as provided under Delaware law, and
shall be entered in the books of the corporation and recorded as they are issued. Any or all of the signatures on any
certificate may be a facsimile or electronic signature. In case any officer, transfer agent or registrar who has
signed or whose facsimile or electronic signature has been placed upon a certificate has ceased to be such officer,
transfer agent or registrar before such certificate is issued, it may be issued by the corporation with the same effect
as if he or she were such officer, transfer agent or registrar at the date of issue.
----

----
Within a reasonable time after the issuance or transfer of uncertificated stock and upon the request of a
stockholder, the corporation shall send to the record owner thereof a written notice that shall set forth the name of
the corporation, that the corporation is organized under the laws of Delaware, the name of the stockholder, the
number and class (and the designation of the series, if any) of the shares, and any restrictions on the transfer or
registration of such shares of stock imposed by the corporation's certificate of incorporation, these bylaws, any
agreement among stockholders or any agreement between stockholders and the corporation.
----

----
The corporation may issue the whole or any part of its shares as partly paid and subject to call for the
remainder of the consideration to be paid therefor. Upon the face or back of each stock certificate (if any) issued to
represent any such partly paid shares, or upon the books and records of the corporation in the case of
uncertificated partly paid shares, the total amount of the consideration to be paid therefor and the amount paid
thereon shall be stated. Upon the declaration of any dividend on fully paid shares, the corporation shall declare a
dividend upon partly paid shares of the same class, but only upon the basis of the percentage of the consideration
actually paid thereon.
----

*8.4.Special Designation On Certificates and Notices of Issuance*

----
If the corporation is authorized to issue more than one class of stock or more than one series of any class,
then the powers, the designations, the preferences, and the relative, participating, optional or other special rights of
each class of stock or series thereof and the qualifications, limitations or restrictions of such preferences and/or
rights shall be set forth in full or summarized on the face or back of the certificate that the corporation shall issue
to represent such class or series of stock or the notice of issuance to the record owner of uncertificated stock;
provided, however, that, except as otherwise provided in Section 202 of the Delaware General Corporation Law,
in lieu of the foregoing requirements there may be set forth on the face or back of the certificate that the
corporation shall issue to represent such class or series of stock or the notice of issuance to the record owner of
uncertificated stock, or the purchase agreement for such stock a statement that the corporation will furnish without
charge to each stockholder who so requests the powers, the designations, the preferences, and the relative,
participating, optional or other special rights of each class of stock or series thereof and the qualifications,
limitations or restrictions of such preferences and/or rights.
----

*8.5.Lost Certificates*

----
Except as provided in this Section 8.5, no new certificates for shares shall be issued to replace a previously
issued certificate unless the latter is surrendered to the corporation and cancelled at the same time. The
corporation may issue a new certificate of stock or notice of uncertificated stock in the place of any certificate
previously issued by it, alleged to have been lost, stolen or destroyed, and the corporation may require the owner
of the lost, stolen or destroyed certificate, or the owner's legal representative, to give the corporation a bond
sufficient to indemnify it against any claim that may be made against it on account of the alleged loss, theft or
destruction of any such certificate or the issuance of such new certificate or uncertificated shares.
----

*8.6.Construction;
Definitions*

----
Unless the context requires otherwise, the general provisions, rules of construction, and definitions in the
Delaware General Corporation Law shall govern the construction of these bylaws. Without limiting the generality
of this provision, the singular number includes the plural, the plural number includes the singular, and the term
""person"" includes both a corporation and a natural person.
----

*8.7.Dividends*

----
The directors of the corporation, subject to any restrictions contained in (a) the Delaware General
Corporation Law or (b) the certificate of incorporation, may declare and pay dividends upon the shares of its
capital stock. Dividends may be paid in cash, in property, or in shares of the corporation's capital stock.
----

----
The directors of the corporation may set apart out of any of the funds of the corporation available for
dividends a reserve or reserves for any proper purpose and may abolish any such reserve. Such purposes shall
include but not be limited to equalizing dividends, repairing or maintaining any property of the corporation, and
meeting contingencies.
----

*8.8.Fiscal Year*

----
The fiscal year of the corporation shall be fixed by resolution of the Board of Directors and may be changed
by the Board of Directors.
----

*8.9.Transfer Restrictions*

----
Notwithstanding anything to the contrary, except as expressly permitted in this Section 8.9, a stockholder
shall not Transfer (as such term is defined below) any shares of the corporation's stock (or any rights of or
----

----
interests in such shares) to any person unless such Transfer is approved by the Board of Directors prior to such
Transfer, which approval may be granted or withheld in the Board of Directors' sole and absolute discretion.
""Transfer"" shall mean, with respect to any security, the direct or indirect assignment, sale, transfer, tender, pledge,
hypothecation, or the grant, creation or suffrage of a lien or encumbrance in or upon, or the gift, placement in
trust, or the Constructive Sale (as such term is defined below) or other disposition of such security (including
transfer by testamentary or intestate succession, merger or otherwise by operation of law) or any right, title or
interest therein (including, but not limited to, any right or power to vote to which the holder thereof may be
entitled, whether such right or power is granted by proxy or otherwise), or the record or beneficial ownership
thereof, the offer to make such a sale, transfer, Constructive Sale or other disposition, and each agreement,
arrangement or understanding, whether or not in writing, to effect any of the foregoing. ""Constructive Sale"" shall
mean, with respect to any security, a short sale with respect to such security, entering into or acquiring an
offsetting derivative contract with respect to such security, entering into or acquiring a futures or forward contract
to deliver such security, or entering into any other hedging or other derivative transaction that has the effect of
materially changing the economic benefits and risks of ownership. Any purported Transfer of any shares of the
corporation's stock effected in violation of this Section 8.9 shall be null and void and shall have no force or effect
and the corporation shall not register any such purported Transfer.
----

----
Any stockholder seeking the approval of the Board of Directors of a Transfer of some or all of its shares shall
give written notice thereof to the Secretary of the corporation that shall include: (a) the name of the stockholder;
(b) the proposed transferee; (c) the number of shares of the Transfer of which approval is thereby requested; and
(d) the purchase price (if any) of the shares proposed for Transfer. The corporation may require the stockholder to
supplement its notice with such additional information as the corporation may request.
----

----
Certificates representing, and in the case of uncertificated securities, notices of issuance with respect to,
shares of stock of the corporation shall have impressed on, printed on, written on or otherwise affixed to them the
following legend:
----

----
THE TRANSFER OF THE SECURITIES REFERENCED HEREIN IS SUBJECT TO CERTAIN
TRANSFER RESTRICTIONS SET FORTH IN THE COMPANY'S BYLAWS, COPIES OF WHICH MAY BE
OBTAINED UPON WRITTEN REQUEST TO THE COMPANY AT ITS PRINCIPAL PLACE OF BUSINESS.
THE COMPANY SHALL NOT REGISTER OR OTHERWISE RECOGNIZE OR GIVE EFFECT TO ANY
PURPORTED TRANSFER OF SECURITIES THAT DOES NOT COMPLY WITH SUCH TRANSFER
RESTRICTIONS.
----

----
The corporation shall take all such actions as are practicable to cause the certificates representing, and
notices of issuance with respect to, shares that are subject to the restrictions on transfer set forth in this Section to
contain the foregoing legend.
----

*8.10.Transfer Of Stock*

----
Upon receipt by the corporation or the transfer agent of the corporation of proper transfer instructions from
the record holder of uncertificated shares or upon surrender to the corporation or the transfer agent of the
corporation of a certificate for shares duly endorsed or accompanied by proper evidence of succession, assignation
or authority to transfer, it shall be the duty of the corporation to issue a new certificate or, in the case of
uncertificated securities and upon request, a notice of issuance of shares, to the person entitled thereto, cancel the
old certificate (if any) and record the transaction in its books.
----

*8.11.Stock Transfer Agreements*

----
The corporation shall have power to enter into and perform any agreement with any number of stockholders
of any one or more classes of stock of the corporation to restrict the transfer of shares of stock of the corporation
of any one or more classes owned by such stockholders in any manner not prohibited by the Delaware General
Corporation Law.
----

*8.12.Stockholders of Record*

----
The corporation shall be entitled to recognize the exclusive right of a person recorded on its books as the
owner of shares to receive dividends and to vote as such owner, shall be entitled to hold liable for calls and
assessments the person recorded on its books as the owner of shares, and shall not be bound to recognize any
equitable or other claim to or interest in such share or shares on the part of another person, whether or not it shall
have express or other notice thereof, except as otherwise provided by the laws of Delaware.
----

*8.13.Facsimile or Electronic Signature*

----
In addition to the provisions for use of facsimile or electronic signatures elsewhere specifically authorized in
these bylaws, facsimile or electronic signatures of any stockholder, director or officer of the corporation may be
used whenever and as authorized by the Board of Directors or a committee thereof.
----

== ARTICLE IX

== AMENDMENTS

The Bylaws of the corporation may be adopted, amended or repealed by the stockholders entitled to vote;
provided, however, that the corporation may, in its certificate of incorporation, confer the power to adopt, amend or repeal Bylaws upon the directors.
The fact that such power has been so conferred upon the directors shall not divest the stockholders of the power, nor limit their power to adopt, amend or repeal Bylaws.
",12387,False,2168.0628744686364,median
"
////
This file is generated! See etc/fields.yml and scripts/generate_field_docs.py
////

[[exported-fields]]
= Exported Fields

[partintro]

--
This document describes the fields that are exported by Metricbeat. They are
grouped in the following categories:

* <<exported-fields-apache>>
* <<exported-fields-beat>>
* <<exported-fields-common>>
* <<exported-fields-mongodb>>
* <<exported-fields-mysql>>
* <<exported-fields-nginx>>
* <<exported-fields-postgresql>>
* <<exported-fields-redis>>
* <<exported-fields-system>>
* <<exported-fields-zookeeper>>

--
[[exported-fields-apache]]
== Apache Fields

Apache HTTPD server metricsets collected from the Apache web server.



[float]
== apache Fields

`apache` contains the metrics that were scraped from Apache.



[float]
== status Fields

`status` contains the metrics that were scraped from the Apache status page.



[float]
=== apache.status.hostname

type: keyword

Apache hostname.


[float]
=== apache.status.total_accesses

type: integer

Total number of access requests.


[float]
=== apache.status.total_kbytes

type: integer

Total number of kilobytes served.


[float]
=== apache.status.requests_per_sec

type: half_float

Requests per second.


[float]
=== apache.status.bytes_per_sec

type: float

Bytes per second.


[float]
=== apache.status.bytes_per_request

type: half_float

Bytes per request.


[float]
=== apache.status.workers.busy

type: integer

Number of busy workers.


[float]
=== apache.status.workers.idle

type: integer

Number of idle workers.


[float]
== uptime Fields

Uptime stats.



[float]
=== apache.status.uptime.server_uptime

type: integer

Server uptime in seconds.


[float]
=== apache.status.uptime.uptime

type: integer

Server uptime.


[float]
== cpu Fields

CPU stats.



[float]
=== apache.status.cpu.load

type: scaled_float

CPU Load.


[float]
=== apache.status.cpu.user

type: scaled_float

CPU user load.


[float]
=== apache.status.cpu.system

type: scaled_float

System cpu.


[float]
=== apache.status.cpu.children_user

type: scaled_float

CPU of children user.


[float]
=== apache.status.cpu.children_system

type: scaled_float

CPU of children system.


[float]
== connections Fields

Connection stats.



[float]
=== apache.status.connections.total

type: integer

Total connections.


[float]
=== apache.status.connections.async.writing

type: integer

Async connection writing.


[float]
=== apache.status.connections.async.keep_alive

type: integer

Async keeped alive connections.


[float]
=== apache.status.connections.async.closing

type: integer

Async closed connections.


[float]
== load Fields

Load averages.



[float]
=== apache.status.load.1

type: half_float

Load average for the last minute.


[float]
=== apache.status.load.5

type: half_float

Load average for the last 5 minutes.


[float]
=== apache.status.load.15

type: half_float

Load average for the last 15 minutes.


[float]
== scoreboard Fields

Scoreboard metrics.



[float]
=== apache.status.scoreboard.starting_up

type: integer

Starting up.


[float]
=== apache.status.scoreboard.reading_request

type: integer

Reading requests.


[float]
=== apache.status.scoreboard.sending_reply

type: integer

Sending Reply.


[float]
=== apache.status.scoreboard.keepalive

type: integer

Keep alive.


[float]
=== apache.status.scoreboard.dns_lookup

type: integer

Dns Lookups.


[float]
=== apache.status.scoreboard.closing_connection

type: integer

Closing connections.


[float]
=== apache.status.scoreboard.logging

type: integer

Logging


[float]
=== apache.status.scoreboard.gracefully_finishing

type: integer

Gracefully finishing.


[float]
=== apache.status.scoreboard.idle_cleanup

type: integer

Idle cleanups.


[float]
=== apache.status.scoreboard.open_slot

type: integer

Open slots.


[float]
=== apache.status.scoreboard.waiting_for_connection

type: integer

Waiting for connections.


[float]
=== apache.status.scoreboard.total

type: integer

Total.


[[exported-fields-beat]]
== Beat Fields

Contains common beat fields available in all event types.



[float]
=== beat.name

The name of the Beat sending the log messages. If the shipper name is set in the configuration file, then that value is used. If it is not set, the hostname is used.


[float]
=== beat.hostname

The hostname as returned by the operating system on which the Beat is running.


[float]
=== @timestamp

type: date

example: 2015-01-24 14:06:05.071000

format: YYYY-MM-DDTHH:MM:SS.milliZ

required: True

The timestamp when the event log record was generated.


[float]
=== tags

Arbitrary tags that can be set per Beat and per transaction type.


[float]
=== fields

type: dict

Contains user configurable fields.


[[exported-fields-common]]
== Common Fields

Contains common fields available in all event types.



[float]
=== metricset.module

The name of the module that generated the event.


[float]
=== metricset.name

The name of the metricset that generated the event.


[float]
=== metricset.host

Hostname of the machine from which the metricset was collected. This field may not be present when the data was collected locally.


[float]
=== metricset.rtt

type: long

required: True

Event round trip time in microseconds.


[float]
=== type

example: metricsets

required: True

The document type. Always set to ""metricsets"".


[[exported-fields-mongodb]]
== MongoDB Fields

Metrics collected from MongoDB servers.



[float]
== mongodb Fields

MongoDB metrics.



[float]
== status Fields

MongoDB server status metrics.



[float]
=== mongodb.status.version

type: keyword

Instance version.


[float]
=== mongodb.status.uptime.ms

type: long

Instance uptime in milliseconds.


[float]
=== mongodb.status.local_time

type: date

Local time as reported by the MongoDB instance.


[float]
=== mongodb.status.asserts.regular

type: long

Number of regular assertions produced by the server.


[float]
=== mongodb.status.asserts.warning

type: long

Number of warning assertions produced by the server.


[float]
=== mongodb.status.asserts.msg

type: long

Number of msg assertions produced by the server.


[float]
=== mongodb.status.asserts.user

type: long

Number of user assertions produced by the server.


[float]
=== mongodb.status.asserts.rollovers

type: long

Number of rollovers assertions produced by the server.


[float]
== background_flushing Fields

Data about the process MongoDB uses to write data to disk. This data is only available for instances that use the MMAPv1 storage engine.



[float]
=== mongodb.status.background_flushing.flushes

type: long

A counter that collects the number of times the database has flushed all writes to disk.


[float]
=== mongodb.status.background_flushing.total.ms

type: long

The total number of milliseconds (ms) that the mongod processes have spent writing (i.e. flushing) data to disk. Because this is an absolute value, consider the value of `flushes` and `average_ms` to provide better context for this datum.


[float]
=== mongodb.status.background_flushing.average.ms

type: long

The average time spent flushing to disk per flush event.


[float]
=== mongodb.status.background_flushing.last.ms

type: long

The amount of time, in milliseconds, that the last flush operation took to complete.


[float]
=== mongodb.status.background_flushing.last_finished

type: date

A timestamp of the last completed flush operation.


[float]
== connections Fields

Data regarding the current status of incoming connections and availability of the database server.



[float]
=== mongodb.status.connections.current

type: long

The number of connections to the database server from clients. This number includes the current shell session. Consider the value of `available` to add more context to this datum.


[float]
=== mongodb.status.connections.available

type: long

The number of unused available incoming connections the database can provide.


[float]
=== mongodb.status.connections.total_created

type: long

A count of all incoming connections created to the server. This number includes connections that have since closed.


[float]
== journaling Fields

Data about the journaling-related operations and performance. Journaling information only appears for mongod instances that use the MMAPv1 storage engine and have journaling enabled.



[float]
=== mongodb.status.journaling.commits

type: long

The number of transactions written to the journal during the last journal group commit interval.


[float]
=== mongodb.status.journaling.journaled.mb

type: long

The amount of data in megabytes (MB) written to journal during the last journal group commit interval.


[float]
=== mongodb.status.journaling.write_to_data_files.mb

type: long

The amount of data in megabytes (MB) written from journal to the data files during the last journal group commit interval.


[float]
=== mongodb.status.journaling.compression

type: long

The compression ratio of the data written to the journal.


[float]
=== mongodb.status.journaling.commits_in_write_lock

type: long

Count of the commits that occurred while a write lock was held. Commits in a write lock indicate a MongoDB node under a heavy write load and call for further diagnosis.


[float]
=== mongodb.status.journaling.early_commits

type: long

The number of times MongoDB requested a commit before the scheduled journal group commit interval.


[float]
== times Fields

Information about the performance of the mongod instance during the various phases of journaling in the last journal group commit interval.



[float]
=== mongodb.status.journaling.times.dt.ms

type: long

The amount of time over which MongoDB collected the times data. Use this field to provide context to the other times field values.


[float]
=== mongodb.status.journaling.times.prep_log_buffer.ms

type: long

The amount of time spent preparing to write to the journal. Smaller values indicate better journal performance.


[float]
=== mongodb.status.journaling.times.write_to_journal.ms

type: long

The amount of time spent actually writing to the journal. File system speeds and device interfaces can affect performance.


[float]
=== mongodb.status.journaling.times.write_to_data_files.ms

type: long

The amount of time spent writing to data files after journaling. File system speeds and device interfaces can affect performance.


[float]
=== mongodb.status.journaling.times.remap_private_view.ms

type: long

The amount of time spent remapping copy-on-write memory mapped views. Smaller values indicate better journal performance.


[float]
=== mongodb.status.journaling.times.commits.ms

type: long

The amount of time spent for commits.


[float]
=== mongodb.status.journaling.times.commits_in_write_lock.ms

type: long

The amount of time spent for commits that occurred while a write lock was held.


[float]
== extra_info Fields

Platform specific data.



[float]
=== mongodb.status.extra_info.heap_usage.bytes

type: long

format: bytes

The total size in bytes of heap space used by the database process. Only available on Unix/Linux.


[float]
=== mongodb.status.extra_info.page_faults

type: long

The total number of page faults that require disk operations. Page faults refer to operations that require the database server to access data that isn't available in active memory.


[float]
== network Fields

Platform specific data.



[float]
=== mongodb.status.network.in.bytes

type: long

format: bytes

The amount of network traffic, in bytes, received by this database.


[float]
=== mongodb.status.network.out.bytes

type: long

format: bytes

The amount of network traffic, in bytes, sent from this database.


[float]
=== mongodb.status.network.requests

type: long

The total number of requests received by the server.


[float]
== opcounters Fields

An overview of database operations by type.



[float]
=== mongodb.status.opcounters.insert

type: long

The total number of insert operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters.query

type: long

The total number of queries received since the mongod instance last started.


[float]
=== mongodb.status.opcounters.update

type: long

The total number of update operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters.delete

type: long

The total number of delete operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters.getmore

type: long

The total number of getmore operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters.command

type: long

The total number of commands issued to the database since the mongod instance last started.


[float]
== opcounters_replicated Fields

An overview of database replication operations by type.



[float]
=== mongodb.status.opcounters_replicated.insert

type: long

The total number of replicated insert operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters_replicated.query

type: long

The total number of replicated queries received since the mongod instance last started.


[float]
=== mongodb.status.opcounters_replicated.update

type: long

The total number of replicated update operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters_replicated.delete

type: long

The total number of replicated delete operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters_replicated.getmore

type: long

The total number of replicated getmore operations received since the mongod instance last started.


[float]
=== mongodb.status.opcounters_replicated.command

type: long

The total number of replicated commands issued to the database since the mongod instance last started.


[float]
== memory Fields

Data about the current memory usage of the mongod server.



[float]
=== mongodb.status.memory.bits

type: long

Either 64 or 32, depending on which target architecture was specified during the mongod compilation process.


[float]
=== mongodb.status.memory.resident.mb

type: long

The amount of RAM, in megabytes (MB), currently used by the database process.


[float]
=== mongodb.status.memory.virtual.mb

type: long

The amount, in megabytes (MB), of virtual memory used by the mongod process.


[float]
=== mongodb.status.memory.mapped.mb

type: long

The amount of mapped memory, in megabytes (MB), used by the database. Because MongoDB uses memory-mapped files, this value is likely to be to be roughly equivalent to the total size of your database or databases.


[float]
=== mongodb.status.memory.mapped_with_journal.mb

type: long

The amount of mapped memory, in megabytes (MB), including the memory used for journaling.


[float]
=== mongodb.status.write_backs_queued

type: boolean

True when there are operations from a mongos instance queued for retrying.


[float]
=== mongodb.status.storage_engine.name

type: keyword

A string that represents the name of the current storage engine.


[[exported-fields-mysql]]
== MySQL Fields

MySQL server status metrics collected from MySQL.



[float]
== mysql Fields

`mysql` contains the metrics that were obtained from MySQL query.



[float]
== status Fields

`status` contains the metrics that were obtained by the status SQL query.



[float]
== aborted Fields

Aborted status fields.



[float]
=== mysql.status.aborted.clients

type: integer

The number of connections that were aborted because the client died without closing the connection properly.


[float]
=== mysql.status.aborted.connects

type: integer

The number of failed attempts to connect to the MySQL server.


[float]
== binlog Fields




[float]
=== mysql.status.binlog.cache.disk_use

type: integer



[float]
=== mysql.status.binlog.cache.use

type: integer



[float]
== bytes Fields

Bytes stats.



[float]
=== mysql.status.bytes.received

type: integer

format: bytes

The number of bytes received from all clients.


[float]
=== mysql.status.bytes.sent

type: integer

format: bytes

The number of bytes sent to all clients.


[float]
=== mysql.status.connections

type: integer



[float]
== created Fields




[float]
=== mysql.status.created.tmp.disk_tables

type: integer



[float]
=== mysql.status.created.tmp.files

type: integer



[float]
=== mysql.status.created.tmp.tables

type: integer



[float]
== delayed Fields




[float]
=== mysql.status.delayed.errors

type: integer



[float]
=== mysql.status.delayed.insert_threads

type: integer



[float]
=== mysql.status.delayed.writes

type: integer



[float]
=== mysql.status.flush_commands

type: integer



[float]
=== mysql.status.max_used_connections

type: integer



[float]
== open Fields




[float]
=== mysql.status.open.files

type: integer



[float]
=== mysql.status.open.streams

type: integer



[float]
=== mysql.status.open.tables

type: integer



[float]
=== mysql.status.opened_tables

type: integer



[[exported-fields-nginx]]
== Nginx Fields

Nginx server status metrics collected from various modules.



[float]
== nginx Fields

`nginx` contains the metrics that were scraped from nginx.



[float]
== stubstatus Fields

`stubstatus` contains the metrics that were scraped from the ngx_http_stub_status_module status page.



[float]
=== nginx.stubstatus.hostname

type: keyword

Nginx hostname.


[float]
=== nginx.stubstatus.active

type: integer

The current number of active client connections including Waiting connections.


[float]
=== nginx.stubstatus.accepts

type: integer

The total number of accepted client connections.


[float]
=== nginx.stubstatus.handled

type: integer

The total number of handled client connections.


[float]
=== nginx.stubstatus.dropped

type: integer

The total number of dropped client connections.


[float]
=== nginx.stubstatus.requests

type: integer

The total number of client requests.


[float]
=== nginx.stubstatus.current

type: integer

The current number of client requests.


[float]
=== nginx.stubstatus.reading

type: integer

The current number of connections where Nginx is reading the request header.


[float]
=== nginx.stubstatus.writing

type: integer

The current number of connections where Nginx is writing the response back to the client.


[float]
=== nginx.stubstatus.waiting

type: integer

The current number of idle client connections waiting for a request.


[[exported-fields-postgresql]]
== PostgreSQL Fields

Metrics collected from PostgreSQL servers.



[float]
== postgresql Fields

PostgreSQL metrics.



[float]
== activity Fields

One document per server process, showing information related to the current activity of that process, such as state and current query. Collected by querying pg_stat_activity.



[float]
=== postgresql.activity.database.oid

type: long

OID of the database this backend is connected to.


[float]
=== postgresql.activity.database.name

type: keyword

Name of the database this backend is connected to.


[float]
=== postgresql.activity.pid

type: integer

Process ID of this backend.


[float]
=== postgresql.activity.user.id

type: long

OID of the user logged into this backend.


[float]
=== postgresql.activity.user.name

Name of the user logged into this backend.


[float]
=== postgresql.activity.application_name

Name of the application that is connected to this backend.


[float]
=== postgresql.activity.client.address

IP address of the client connected to this backend.


[float]
=== postgresql.activity.client.hostname

Host name of the connected client, as reported by a reverse DNS lookup of client_addr.


[float]
=== postgresql.activity.client.port

type: integer

TCP port number that the client is using for communication with this backend, or -1 if a Unix socket is used.


[float]
=== postgresql.activity.backend_start

type: date

Time when this process was started, i.e., when the client connected to the server.


[float]
=== postgresql.activity.transaction_start

type: date

Time when this process' current transaction was started.


[float]
=== postgresql.activity.query_start

type: date

Time when the currently active query was started, or if state is not active, when the last query was started.


[float]
=== postgresql.activity.state_change

type: date

Time when the state was last changed.


[float]
=== postgresql.activity.waiting

type: boolean

True if this backend is currently waiting on a lock.


[float]
=== postgresql.activity.state

Current overall state of this backend. Possible values are:

  * active: The backend is executing a query.
  * idle: The backend is waiting for a new client command.
  * idle in transaction: The backend is in a transaction, but is not
    currently executing a query.
  * idle in transaction (aborted): This state is similar to idle in
    transaction, except one of the statements in the transaction caused
    an error.
  * fastpath function call: The backend is executing a fast-path function.
  * disabled: This state is reported if track_activities is disabled in this backend.


[float]
=== postgresql.activity.query

Text of this backend's most recent query. If state is active this field shows the currently executing query. In all other states, it shows the last query that was executed.


[float]
== database Fields

One row per database, showing database-wide statistics. Collected by querying pg_stat_database



[float]
=== postgresql.database.oid

type: long

OID of the database this backend is connected to.


[float]
=== postgresql.database.name

type: keyword

Name of the database this backend is connected to.


[float]
=== postgresql.database.number_of_backends

type: long

Number of backends currently connected to this database.


[float]
=== postgresql.database.transactions.commit

type: long

Number of transactions in this database that have been committed.


[float]
=== postgresql.database.transactions.rollback

type: long

Number of transactions in this database that have been rolled back.


[float]
=== postgresql.database.blocks.read

type: long

Number of disk blocks read in this database.


[float]
=== postgresql.database.blocks.hit

type: long

Number of times disk blocks were found already in the buffer cache, so that a read was not necessary (this only includes hits in the PostgreSQL buffer cache, not the operating system's file system cache).


[float]
=== postgresql.database.blocks.time.read.ms

type: long

Time spent reading data file blocks by backends in this database, in milliseconds.


[float]
=== postgresql.database.blocks.time.write.ms

type: long

Time spent writing data file blocks by backends in this database, in milliseconds.


[float]
=== postgresql.database.rows.returned

type: long

Number of rows returned by queries in this database.


[float]
=== postgresql.database.rows.fetched

type: long

Number of rows fetched by queries in this database.


[float]
=== postgresql.database.rows.inserted

type: long

Number of rows inserted by queries in this database.


[float]
=== postgresql.database.rows.updated

type: long

Number of rows updated by queries in this database.


[float]
=== postgresql.database.rows.deleted

type: long

Number of rows deleted by queries in this database.


[float]
=== postgresql.database.conflicts

type: long

Number of queries canceled due to conflicts with recovery in this database.


[float]
=== postgresql.database.temporary.files

type: long

Number of temporary files created by queries in this database. All temporary files are counted, regardless of why the temporary file was created (e.g., sorting or hashing), and regardless of the log_temp_files setting.


[float]
=== postgresql.database.temporary.bytes

type: long

Total amount of data written to temporary files by queries in this database. All temporary files are counted, regardless of why the temporary file was created, and regardless of the log_temp_files setting.


[float]
=== postgresql.database.deadlocks

type: long

Number of deadlocks detected in this database.


[float]
=== postgresql.database.stats_reset

type: date

Time at which these statistics were last reset.


[[exported-fields-redis]]
== Redis Fields

Redis metrics collected from Redis.



[float]
== redis Fields

`redis` contains the information and statistics from Redis.



[float]
== info Fields

`info` contains the information and statistics returned by the `INFO` command.



[float]
== clients Fields

Redis client stats.



[float]
=== redis.info.clients.connected

type: integer

Number of client connections (excluding connections from slaves).


[float]
=== redis.info.clients.longest_output_list

type: integer

Longest output list among current client connections.


[float]
=== redis.info.clients.biggest_input_buf

type: integer

Biggest input buffer among current client connections.


[float]
=== redis.info.clients.blocked

type: integer

Number of clients pending on a blocking call (BLPOP, BRPOP, BRPOPLPUSH).


[float]
== cluster Fields

Redis cluster information.



[float]
=== redis.info.cluster.enabled

type: boolean

Indicates that the Redis cluster is enabled.


[float]
== cpu Fields

Redis CPU stats



[float]
=== redis.info.cpu.used.sys

type: half_float

System CPU consumed by the Redis server.


[float]
=== redis.info.cpu.used.sys_children

type: half_float

User CPU consumed by the Redis server.


[float]
=== redis.info.cpu.used.user

type: half_float

System CPU consumed by the background processes.


[float]
=== redis.info.cpu.used.user_children

type: half_float

User CPU consumed by the background processes.


[float]
== memory Fields

Redis CPU stats.



[float]
=== redis.info.memory.used.value

type: integer

Used memory.


[float]
=== redis.info.memory.used.rss

type: integer

Used memory rss.


[float]
=== redis.info.memory.used.peak

type: integer

Used memory peak.


[float]
=== redis.info.memory.used.lua

type: integer

Used memory lua.


[float]
=== redis.info.memory.allocator

type: keyword

Memory allocator.


[float]
== persistence Fields

Redis CPU stats.



[float]
=== redis.info.persistence.loading

type: boolean

None

[float]
=== redis.info.persistence.rdb.changes_since_last_save

type: integer

None

[float]
=== redis.info.persistence.rdb.bgsave_in_progress

type: boolean

None

[float]
=== redis.info.persistence.rdb.last_save_time

type: integer

None

[float]
=== redis.info.persistence.rdb.last_bgsave_status

type: keyword

None

[float]
=== redis.info.persistence.rdb.last_bgsave_time_sec

type: integer

None

[float]
=== redis.info.persistence.rdb.current_bgsave_time_sec

type: integer

None

[float]
=== redis.info.persistence.aof.enabled

type: boolean

None

[float]
=== redis.info.persistence.aof.rewrite_in_progress

type: boolean

None

[float]
=== redis.info.persistence.aof.rewrite_scheduled

type: boolean

None

[float]
=== redis.info.persistence.aof.last_rewrite_time_sec

type: integer

None

[float]
=== redis.info.persistence.aof.current_rewrite_time_sec

type: integer

None

[float]
=== redis.info.persistence.aof.last_bgrewrite_status

type: keyword

None

[float]
=== redis.info.persistence.aof.last_write_status

type: keyword

None

[float]
== replication Fields

Replication



[float]
=== redis.info.replication.role

type: keyword

None

[float]
=== redis.info.replication.connected_slaves

type: integer

None

[float]
=== redis.info.replication.master_offset

type: integer

None

[float]
=== redis.info.replication.backlog.active

type: integer

None

[float]
=== redis.info.replication.backlog.size

type: integer

None

[float]
=== redis.info.replication.backlog.first_byte_offset

type: integer

None

[float]
=== redis.info.replication.backlog.histlen

type: integer

None

[float]
== server Fields

Server info



[float]
=== redis.info.server.version

type: keyword

None

[float]
=== redis.info.server.git_sha1

type: keyword

None

[float]
=== redis.info.server.git_dirty

type: keyword

None

[float]
=== redis.info.server.build_id

type: keyword

None

[float]
=== redis.info.server.mode

type: keyword

None

[float]
=== redis.info.server.os

type: keyword

None

[float]
=== redis.info.server.arch_bits

type: keyword

None

[float]
=== redis.info.server.multiplexing_api

type: keyword

None

[float]
=== redis.info.server.gcc_version

type: keyword

None

[float]
=== redis.info.server.process_id

type: integer

None

[float]
=== redis.info.server.run_id

type: keyword

None

[float]
=== redis.info.server.tcp_port

type: integer

None

[float]
=== redis.info.server.uptime

type: integer

None

[float]
=== redis.info.server.hz

type: integer

None

[float]
=== redis.info.server.lru_clock

type: integer

None

[float]
=== redis.info.server.config_file

type: keyword

None

[float]
== stats Fields

Redis stats.



[float]
=== redis.info.stats.connections.received

type: integer

None

[float]
=== redis.info.stats.connections.rejected

type: integer

None

[float]
=== redis.info.stats.total_commands_processed

type: integer

None

[float]
=== redis.info.stats.total_net_input_bytes

type: integer

None

[float]
=== redis.info.stats.total_net_output_bytes

type: integer

None

[float]
=== redis.info.stats.instantaneous_ops_per_sec

type: integer

None

[float]
=== redis.info.stats.instantaneous_input_kbps

type: float

None

[float]
=== redis.info.stats.instantaneous_output_kbps

type: float

None

[float]
=== redis.info.stats.sync.full

type: integer

None

[float]
=== redis.info.stats.sync.partial_ok

type: integer

None

[float]
=== redis.info.stats.sync.partial_err

type: integer

None

[float]
=== redis.info.stats.keys.expired

type: integer

None

[float]
=== redis.info.stats.keys.evicted

type: integer

None

[float]
=== redis.info.stats.keyspace.hits

type: integer

None

[float]
=== redis.info.stats.keyspace.misses

type: integer

None

[float]
=== redis.info.stats.pubsub_channels

type: integer

None

[float]
=== redis.info.stats.pubsub_patterns

type: integer

None

[float]
=== redis.info.stats.latest_fork_usec

type: integer

None

[float]
=== redis.info.stats.migrate_cached_sockets

type: integer

None

[float]
== keyspace Fields

`keyspace` contains the information about the keyspaces returned by the `INFO` command.



[float]
=== redis.keyspace.id

type: keyword

Keyspace identifier.


[float]
=== redis.keyspace.avg_ttl

type: long

Average ttl.


[float]
=== redis.keyspace.keys

type: long

Number of keys in the keyspace.


[float]
=== redis.keyspace.expires

type: long



[[exported-fields-system]]
== System Fields

System status metrics, like CPU and memory usage, that are collected from the operating system.



[float]
== system Fields

`system` contains local system metrics.



[float]
== core Fields

`system-core` contains local CPU core stats.



[float]
=== system.core.id

type: integer

CPU Core number.


[float]
=== system.core.user.pct

type: scaled_float

format: percent

The percentage of CPU time spent in user space. On multi-core systems, you can have percentages that are greater than 100%. For example, if 3 cores are at 60% use, then the `cpu.user_p` will be 180%.


[float]
=== system.core.user.ticks

type: long

The amount of CPU time spent in user space.


[float]
=== system.core.system.pct

type: scaled_float

format: percent

The percentage of CPU time spent in kernel space.


[float]
=== system.core.system.ticks

type: long

The amount of CPU time spent in kernel space.


[float]
=== system.core.nice.pct

type: scaled_float

format: percent

The percentage of CPU time spent on low-priority processes.


[float]
=== system.core.nice.ticks

type: long

The amount of CPU time spent on low-priority processes.


[float]
=== system.core.idle.pct

type: scaled_float

format: percent

The percentage of CPU time spent idle.


[float]
=== system.core.idle.ticks

type: long

The amount of CPU time spent idle.


[float]
=== system.core.iowait.pct

type: scaled_float

format: percent

The percentage of CPU time spent in wait (on disk).


[float]
=== system.core.iowait.ticks

type: long

The amount of CPU time spent in wait (on disk).


[float]
=== system.core.irq.pct

type: scaled_float

format: percent

The percentage of CPU time spent servicing and handling hardware interrupts.


[float]
=== system.core.irq.ticks

type: long

The amount of CPU time spent servicing and handling hardware interrupts.


[float]
=== system.core.softirq.pct

type: scaled_float

format: percent

The percentage of CPU time spent servicing and handling software interrupts.


[float]
=== system.core.softirq.ticks

type: long

The amount of CPU time spent servicing and handling software interrupts.


[float]
=== system.core.steal.pct

type: scaled_float

format: percent

The percentage of CPU time spent in involuntary wait by the virtual CPU while the hypervisor was servicing another processor. Available only on Unix.


[float]
=== system.core.steal.ticks

type: long

The amount of CPU time spent in involuntary wait by the virtual CPU while the hypervisor was servicing another processor. Available only on Unix.


[float]
== cpu Fields

`cpu` contains local CPU stats.



[float]
=== system.cpu.user.pct

type: scaled_float

format: percent

The percentage of CPU time spent in user space. On multi-core systems, you can have percentages that are greater than 100%. For example, if 3 cores are at 60% use, then the `cpu.user_p` will be 180%.


[float]
=== system.cpu.system.pct

type: scaled_float

format: percent

The percentage of CPU time spent in kernel space.


[float]
=== system.cpu.nice.pct

type: scaled_float

format: percent

The percentage of CPU time spent on low-priority processes.


[float]
=== system.cpu.idle.pct

type: scaled_float

format: percent

The percentage of CPU time spent idle.


[float]
=== system.cpu.iowait.pct

type: scaled_float

format: percent

The percentage of CPU time spent in wait (on disk).


[float]
=== system.cpu.irq.pct

type: scaled_float

format: percent

The percentage of CPU time spent servicing and handling hardware interrupts.


[float]
=== system.cpu.softirq.pct

type: scaled_float

format: percent

The percentage of CPU time spent servicing and handling software interrupts.


[float]
=== system.cpu.steal.pct

type: scaled_float

format: percent

The percentage of CPU time spent in involuntary wait by the virtual CPU while the hypervisor was servicing another processor. Available only on Unix.


[float]
=== system.cpu.user.ticks

type: long

The amount of CPU time spent in user space.


[float]
=== system.cpu.system.ticks

type: long

The amount of CPU time spent in kernel space.


[float]
=== system.cpu.nice.ticks

type: long

The amount of CPU time spent on low-priority processes.


[float]
=== system.cpu.idle.ticks

type: long

The amount of CPU time spent idle.


[float]
=== system.cpu.iowait.ticks

type: long

The amount of CPU time spent in wait (on disk).


[float]
=== system.cpu.irq.ticks

type: long

The amount of CPU time spent servicing and handling hardware interrupts.


[float]
=== system.cpu.softirq.ticks

type: long

The amount of CPU time spent servicing and handling software interrupts.


[float]
=== system.cpu.steal.ticks

type: long

The amount of CPU time spent in involuntary wait by the virtual CPU while the hypervisor was servicing another processor. Available only on Unix.


[float]
== diskio Fields

`disk` contains disk IO metrics collected from the operating system.



[float]
=== system.diskio.name

type: keyword

example: sda1

The disk name.


[float]
=== system.diskio.serial_number

type: keyword

The disk's serial number. This may not be provided by all operating systems.


[float]
=== system.diskio.read.count

type: long

The total number of reads completed successfully.


[float]
=== system.diskio.write.count

type: long

The total number of writes completed successfully.


[float]
=== system.diskio.read.bytes

type: long

format: bytes

The total number of bytes read successfully. On Linux this is the number of sectors read multiplied by an assumed sector size of 512.


[float]
=== system.diskio.write.bytes

type: long

format: bytes

The total number of bytes written successfully. On Linux this is the number of sectors written multiplied by an assumed sector size of 512.


[float]
=== system.diskio.read.time

type: long

The total number of milliseconds spent by all reads.


[float]
=== system.diskio.write.time

type: long

The total number of milliseconds spent by all writes.


[float]
=== system.diskio.io.time

type: long

The total number of of milliseconds spent doing I/Os.


[float]
== filesystem Fields

`filesystem` contains local filesystem stats.



[float]
=== system.filesystem.available

type: long

format: bytes

The disk space available to an unprivileged user in bytes.


[float]
=== system.filesystem.device_name

type: keyword

The disk name. For example: `/dev/disk1`


[float]
=== system.filesystem.mount_point

type: keyword

The mounting point. For example: `/`


[float]
=== system.filesystem.files

type: long

The total number of file nodes in the file system.


[float]
=== system.filesystem.free

type: long

format: bytes

The disk space available in bytes.


[float]
=== system.filesystem.free_files

type: long

The number of free file nodes in the file system.


[float]
=== system.filesystem.total

type: long

format: bytes

The total disk space in bytes.


[float]
=== system.filesystem.used.bytes

type: long

format: bytes

The used disk space in bytes.


[float]
=== system.filesystem.used.pct

type: scaled_float

format: percent

The percentage of used disk space.


[float]
== fsstat Fields

`system.fsstat` contains filesystem metrics aggregated from all mounted filesystems.



[float]
=== system.fsstat.count

type: long

Number of file systems found.

[float]
=== system.fsstat.total_files

type: long

Total number of files.

[float]
== total_size Fields

Nested file system docs.


[float]
=== system.fsstat.total_size.free

type: long

format: bytes

Total free space.


[float]
=== system.fsstat.total_size.used

type: long

format: bytes

Total used space.


[float]
=== system.fsstat.total_size.total

type: long

format: bytes

Total space (used plus free).


[float]
== load Fields

Load averages.



[float]
=== system.load.1

type: scaled_float

Load average for the last minute.


[float]
=== system.load.5

type: scaled_float

Load average for the last 5 minutes.


[float]
=== system.load.15

type: scaled_float

Load average for the last 15 minutes.


[float]
=== system.load.norm.1

type: scaled_float

Load divided by the number of cores for the last minute.


[float]
=== system.load.norm.5

type: scaled_float

Load divided by the number of cores for the last 5 minutes.


[float]
=== system.load.norm.15

type: scaled_float

Load divided by the number of cores for the last 15 minutes.


[float]
== memory Fields

`memory` contains local memory stats.



[float]
=== system.memory.total

type: long

format: bytes

Total memory.


[float]
=== system.memory.used.bytes

type: long

format: bytes

Used memory.


[float]
=== system.memory.free

type: long

format: bytes

The total amount of free memory in bytes. This value does not include memory consumed by system caches and buffers (see system.memory.actual.free).


[float]
=== system.memory.used.pct

type: scaled_float

format: percent

The percentage of used memory.


[float]
== actual Fields

Actual memory used and free.



[float]
=== system.memory.actual.used.bytes

type: long

Actual used memory in bytes. It represents the difference between the total and the available memory. The available memory depends on the OS. For more details, please check `system.actual.free`.


[float]
=== system.memory.actual.free

type: long

Actual free memory in bytes. It is calculated based on the OS. On Linux it consists of the free memory plus caches and buffers. On OSX it is a sum of free memory and the inactive memory. On Windows, it is the  amount of unreserved and uncommitted memory currently in the user-mode portion of the virtual address space of the calling process.


[float]
=== system.memory.actual.used.pct

type: scaled_float

The percentage of actual used memory.


[float]
== swap Fields

This group contains statistics related to the swap memory usage on the system.


[float]
=== system.memory.swap.total

type: long

format: bytes

Total swap memory.


[float]
=== system.memory.swap.used.bytes

type: long

format: bytes

Used swap memory.


[float]
=== system.memory.swap.free

type: long

format: bytes

Available swap memory.


[float]
=== system.memory.swap.used.pct

type: scaled_float

format: percent

The percentage of used swap memory.


[float]
== network Fields

`network` contains network IO metrics for a single network interface.



[float]
=== system.network.name

type: keyword

example: eth0

The network interface name.


[float]
=== system.network.out.bytes

type: long

format: bytes

The number of bytes sent.


[float]
=== system.network.in.bytes

type: long

format: bytes

The number of bytes received.


[float]
=== system.network.out.packets

type: long

The number of packets sent.


[float]
=== system.network.in.packets

type: long

The number or packets received.


[float]
=== system.network.in.errors

type: long

The number of errors while receiving.


[float]
=== system.network.out.errors

type: long

The number of errors while sending.


[float]
=== system.network.in.dropped

type: long

The number of incoming packets that were dropped.


[float]
=== system.network.out.dropped

type: long

The number of outgoing packets that were dropped. This value is always 0 on Darwin and BSD because it is not reported by the operating system.


[float]
== process Fields

`process` contains process metadata, CPU metrics, and memory metrics.



[float]
=== system.process.name

type: keyword

The process name.


[float]
=== system.process.state

type: keyword

The process state. For example: ""running"".


[float]
=== system.process.pid

type: integer

The process pid.


[float]
=== system.process.ppid

type: integer

The process parent pid.


[float]
=== system.process.pgid

type: integer

The process group id.


[float]
=== system.process.cmdline

type: keyword

The full command-line used to start the process, including the arguments separated by space.


[float]
=== system.process.username

type: keyword

The username of the user that created the process. If the username cannot be determined, the field will contain the user's numeric identifier (UID). On Windows, this field includes the user's domain and is formatted as `domain\\username`.


[float]
== cpu Fields

CPU-specific statistics per process.


[float]
=== system.process.cpu.user

type: long

The amount of CPU time the process spent in user space.


[float]
=== system.process.cpu.total.pct

type: scaled_float

format: percent

The percentage of CPU time spent by the process since the last update. Its value is similar to the %CPU value of the process displayed by the top command on Unix systems.


[float]
=== system.process.cpu.system

type: long

The amount of CPU time the process spent in kernel space.


[float]
=== system.process.cpu.total.ticks

type: long

The total CPU time spent by the process.


[float]
=== system.process.cpu.start_time

type: date

The time when the process was started.


[float]
== memory Fields

Memory-specific statistics per process.


[float]
=== system.process.memory.size

type: long

format: bytes

The total virtual memory the process has.


[float]
=== system.process.memory.rss.bytes

type: long

format: bytes

The Resident Set Size. The amount of memory the process occupied in main memory (RAM).


[float]
=== system.process.memory.rss.pct

type: scaled_float

format: percent

The percentage of memory the process occupied in main memory (RAM).


[float]
=== system.process.memory.share

type: long

format: bytes

The shared memory the process uses.


[float]
== fd Fields

File descriptor usage metrics. This set of metrics is available for Linux and FreeBSD.



[float]
=== system.process.fd.open

type: long

The number of file descriptors open by the process.

[float]
=== system.process.fd.limit.soft

type: long

The soft limit on the number of file descriptors opened by the process. The soft limit can be changed by the process at any time.


[float]
=== system.process.fd.limit.hard

type: long

The hard limit on the number of file descriptors opened by the process. The hard limit can only be raised by root.


[float]
== cgroup Fields

Metrics and limits from the cgroup of which the task is a member. cgroup metrics are reported when the process has membership in a non-root cgroup. These metrics are only available on Linux.



[float]
=== system.process.cgroup.id

type: keyword

The ID common to all cgroups associated with this task. If there isn't a common ID used by all cgroups this field will be absent.


[float]
=== system.process.cgroup.path

type: keyword

The path to the cgroup relative to the cgroup subsystem's mountpoint. If there isn't a common path used by all cgroups this field will be absent.


[float]
== cpu Fields

The cpu subsystem schedules CPU access for tasks in the cgroup. Access can be controlled by two separate schedulers, CFS and RT. CFS stands for completely fair scheduler which proportionally divides the CPU time between cgroups based on weight. RT stands for real time scheduler which sets a maximum amount of CPU time that processes in the cgroup can consume during a given period.



[float]
=== system.process.cgroup.cpu.id

type: keyword

ID of the cgroup.

[float]
=== system.process.cgroup.cpu.path

type: keyword

Path to the cgroup relative to the cgroup subsystem's mountpoint.


[float]
=== system.process.cgroup.cpu.cfs.period.us

type: long

Period of time in microseconds for how regularly a cgroup's access to CPU resources should be reallocated.


[float]
=== system.process.cgroup.cpu.cfs.quota.us

type: long

Total amount of time in microseconds for which all tasks in a cgroup can run during one period (as defined by cfs.period.us).


[float]
=== system.process.cgroup.cpu.cfs.shares

type: long

An integer value that specifies a relative share of CPU time available to the tasks in a cgroup. The value specified in the cpu.shares file must be 2 or higher.


[float]
=== system.process.cgroup.cpu.rt.period.us

type: long

Period of time in microseconds for how regularly a cgroup's access to CPU resources is reallocated.


[float]
=== system.process.cgroup.cpu.rt.runtime.us

type: long

Period of time in microseconds for the longest continuous period in which the tasks in a cgroup have access to CPU resources.


[float]
=== system.process.cgroup.cpu.stats.periods

type: long

Number of period intervals (as specified in cpu.cfs.period.us) that have elapsed.


[float]
=== system.process.cgroup.cpu.stats.throttled.periods

type: long

Number of times tasks in a cgroup have been throttled (that is, not allowed to run because they have exhausted all of the available time as specified by their quota).


[float]
=== system.process.cgroup.cpu.stats.throttled.ns

type: long

The total time duration (in nanoseconds) for which tasks in a cgroup have been throttled.


[float]
== cpuacct Fields

CPU accounting metrics.


[float]
=== system.process.cgroup.cpuacct.id

type: keyword

ID of the cgroup.

[float]
=== system.process.cgroup.cpuacct.path

type: keyword

Path to the cgroup relative to the cgroup subsystem's mountpoint.


[float]
=== system.process.cgroup.cpuacct.total.ns

type: long

Total CPU time in nanoseconds consumed by all tasks in the cgroup.


[float]
=== system.process.cgroup.cpuacct.stats.user.ns

type: long

CPU time consumed by tasks in user mode.

[float]
=== system.process.cgroup.cpuacct.stats.system.ns

type: long

CPU time consumed by tasks in user (kernel) mode.

[float]
=== system.process.cgroup.cpuacct.percpu

type: dict

CPU time (in nanoseconds) consumed on each CPU by all tasks in this cgroup.


[float]
== memory Fields

Memory limits and metrics.


[float]
=== system.process.cgroup.memory.id

type: keyword

ID of the cgroup.

[float]
=== system.process.cgroup.memory.path

type: keyword

Path to the cgroup relative to the cgroup subsystem's mountpoint.


[float]
=== system.process.cgroup.memory.mem.usage.bytes

type: long

Total memory usage by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.mem.usage.max.bytes

type: long

The maximum memory used by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.mem.limit.bytes

type: long

The maximum amount of user memory in bytes (including file cache) that tasks in the cgroup are allowed to use.


[float]
=== system.process.cgroup.memory.mem.failures

type: long

The number of times that the memory limit (mem.limit.bytes) was reached.


[float]
=== system.process.cgroup.memory.memsw.usage.bytes

type: long

The sum of current memory usage plus swap space used by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.memsw.usage.max.bytes

type: long

The maximum amount of memory and swap space used by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.memsw.limit.bytes

type: long

The maximum amount for the sum of memory and swap usage that tasks in the cgroup are allowed to use.


[float]
=== system.process.cgroup.memory.memsw.failures

type: long

The number of times that the memory plus swap space limit (memsw.limit.bytes) was reached.


[float]
=== system.process.cgroup.memory.kmem.usage.bytes

type: long

Total kernel memory usage by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.kmem.usage.max.bytes

type: long

The maximum kernel memory used by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.kmem.limit.bytes

type: long

The maximum amount of kernel memory that tasks in the cgroup are allowed to use.


[float]
=== system.process.cgroup.memory.kmem.failures

type: long

The number of times that the memory limit (kmem.limit.bytes) was reached.


[float]
=== system.process.cgroup.memory.kmem_tcp.usage.bytes

type: long

Total memory usage for TCP buffers in bytes.


[float]
=== system.process.cgroup.memory.kmem_tcp.usage.max.bytes

type: long

The maximum memory used for TCP buffers by processes in the cgroup (in bytes).


[float]
=== system.process.cgroup.memory.kmem_tcp.limit.bytes

type: long

The maximum amount of memory for TCP buffers that tasks in the cgroup are allowed to use.


[float]
=== system.process.cgroup.memory.kmem_tcp.failures

type: long

The number of times that the memory limit (kmem_tcp.limit.bytes) was reached.


[float]
=== system.process.cgroup.memory.stats.active_anon.bytes

type: long

Anonymous and swap cache on active least-recently-used (LRU) list, including tmpfs (shmem), in bytes.


[float]
=== system.process.cgroup.memory.stats.active_file.bytes

type: long

File-backed memory on active LRU list, in bytes.

[float]
=== system.process.cgroup.memory.stats.cache.bytes

type: long

Page cache, including tmpfs (shmem), in bytes.

[float]
=== system.process.cgroup.memory.stats.hierarchical_memory_limit.bytes

type: long

Memory limit for the hierarchy that contains the memory cgroup, in bytes.


[float]
=== system.process.cgroup.memory.stats.hierarchical_memsw_limit.bytes

type: long

Memory plus swap limit for the hierarchy that contains the memory cgroup, in bytes.


[float]
=== system.process.cgroup.memory.stats.inactive_anon.bytes

type: long

Anonymous and swap cache on inactive LRU list, including tmpfs (shmem), in bytes


[float]
=== system.process.cgroup.memory.stats.inactive_file.bytes

type: long

File-backed memory on inactive LRU list, in bytes.


[float]
=== system.process.cgroup.memory.stats.mapped_file.bytes

type: long

Size of memory-mapped mapped files, including tmpfs (shmem), in bytes.


[float]
=== system.process.cgroup.memory.stats.page_faults

type: long

Number of times that a process in the cgroup triggered a page fault.


[float]
=== system.process.cgroup.memory.stats.major_page_faults

type: long

Number of times that a process in the cgroup triggered a major fault. ""Major"" faults happen when the kernel actually has to read the data from disk.


[float]
=== system.process.cgroup.memory.stats.pages_in

type: long

Number of pages paged into memory. This is a counter.


[float]
=== system.process.cgroup.memory.stats.pages_out

type: long

Number of pages paged out of memory. This is a counter.


[float]
=== system.process.cgroup.memory.stats.rss.bytes

type: long

Anonymous and swap cache (includes transparent hugepages), not including tmpfs (shmem), in bytes.


[float]
=== system.process.cgroup.memory.stats.rss_huge.bytes

type: long

Number of bytes of anonymous transparent hugepages.


[float]
=== system.process.cgroup.memory.stats.swap.bytes

type: long

Swap usage, in bytes.


[float]
=== system.process.cgroup.memory.stats.unevictable.bytes

type: long

Memory that cannot be reclaimed, in bytes.


[float]
== blkio Fields

Block IO metrics.


[float]
=== system.process.cgroup.blkio.id

type: keyword

ID of the cgroup.

[float]
=== system.process.cgroup.blkio.path

type: keyword

Path to the cgroup relative to the cgroup subsystems mountpoint.


[float]
=== system.process.cgroup.blkio.total.bytes

type: keyword

Total number of bytes transferred to and from all block devices by processes in the cgroup.


[float]
=== system.process.cgroup.blkio.total.ios

type: keyword

Total number of I/O operations performed on all devices by processes in the cgroup as seen by the throttling policy.


[[exported-fields-zookeeper]]
== ZooKeeper Fields

ZooKeeper metrics collected by the four-letter monitoring commands.



[float]
== zookeeper Fields

`zookeeper` contains the metrics reported by ZooKeeper commands.



[float]
== mntr Fields

`mntr` contains the metrics reported by the four-letter `mntr` command.



[float]
=== zookeeper.mntr.hostname

type: keyword

ZooKeeper hostname.


[float]
=== zookeeper.mntr.approximate_data_size

type: long

Approximate size of ZooKeeper data.


[float]
=== zookeeper.mntr.latency.avg

type: integer

Average latency between ensemble hosts in milliseconds.


[float]
=== zookeeper.mntr.ephemerals_count

type: integer

Number of ephemeral znodes.


[float]
=== zookeeper.mntr.followers

type: integer

Number of followers seen by the current host.


[float]
=== zookeeper.mntr.max_file_descriptor_count

type: integer

Maximum number of file descriptors allowed for the ZooKeeper process.


[float]
=== zookeeper.mntr.latency.max

type: integer

Maximum latency in milliseconds.


[float]
=== zookeeper.mntr.latency.min

type: integer

Minimum latency in milliseconds.


[float]
=== zookeeper.mntr.num_alive_connections

type: integer

Number of connections to ZooKeeper that are currently alive.


[float]
=== zookeeper.mntr.open_file_descriptor_count

type: integer

Number of file descriptors open by the ZooKeeper process.


[float]
=== zookeeper.mntr.outstanding_requests

type: integer

Number of outstanding requests that need to be processed by the cluster.


[float]
=== zookeeper.mntr.packets.received

type: integer

Number of ZooKeeper network packets received.


[float]
=== zookeeper.mntr.packets.sent

type: long

Number of ZooKeeper network packets sent.


[float]
=== zookeeper.mntr.pending_syncs

type: integer

Number of pending syncs to carry out to ZooKeeper ensemble followers.


[float]
=== zookeeper.mntr.server_state

type: keyword

Role in the ZooKeeper ensemble.


[float]
=== zookeeper.mntr.synced_followers

type: integer

Number of synced followers reported when a node server_state is leader.


[float]
=== zookeeper.mntr.version

type: keyword

ZooKeeper version and build string reported.


[float]
=== zookeeper.mntr.watch_count

type: integer

Number of watches currently set on the local ZooKeeper process.


[float]
=== zookeeper.mntr.znode_count

type: integer

Number of znodes reported by the local ZooKeeper process.


",12281,True,2544.76295510914,median
"/*
 * refit/lib.c
 * General library functions
 *
 * Copyright (c) 2006-2009 Christoph Pfisterer
 * 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 Christoph Pfisterer nor the names of the
 *    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 ""Platform.h""
#include ""screen.h""

#ifndef DEBUG_ALL
#define DEBUG_LIB 1
#else
#define DEBUG_LIB DEBUG_ALL
#endif

#if DEBUG_LIB == 0
#define DBG(...)
#else
#define DBG(...) DebugLog(DEBUG_LIB, __VA_ARGS__)
#endif

// variables

EFI_HANDLE       SelfImageHandle;
EFI_HANDLE       SelfDeviceHandle;
EFI_LOADED_IMAGE *SelfLoadedImage;
EFI_FILE         *SelfRootDir;
EFI_FILE         *SelfDir;
CHAR16           *SelfDirPath;
EFI_DEVICE_PATH  *SelfDevicePath;
EFI_DEVICE_PATH  *SelfFullDevicePath;

XTheme ThemeX;

CHAR16           *ThemePath;
BOOLEAN          gThemeChanged = FALSE;
//BOOLEAN          gBootArgsChanged = FALSE;
BOOLEAN          gBootChanged = FALSE;
BOOLEAN          gThemeOptionsChanged = FALSE;

EFI_FILE         *OEMDir;
CHAR16           *OEMPath;
EFI_FILE         *OemThemeDir = NULL;


REFIT_VOLUME     *SelfVolume = NULL;
//REFIT_VOLUME     **Volumes = NULL;
//UINTN            VolumesCount = 0;
XObjArray<REFIT_VOLUME> Volumes;
//
// Unicode collation protocol interface
//
EFI_UNICODE_COLLATION_PROTOCOL *mUnicodeCollation = NULL;

// functions

static EFI_STATUS FinishInitRefitLib(VOID);

static VOID UninitVolumes(VOID);

// S. Mtr
/* Function for parsing nodes from device path
 * IN : DevicePath, sizeof(DevicePath)
 * OUT: Size of cutted device path
 * Description:
 * Device path contains device nodes.
 * From UEFI specification device node struct looks like:
 *typedef struct {
 *  UINT8 Type;   ///< 0x01 Hardware Device Path.
 *                ///< 0x02 ACPI Device Path.
 *                ///< 0x03 Messaging Device Path.
 *                ///< 0x04 Media Device Path.
 *                ///< 0x05 BIOS Boot Specification Device Path.
 *                ///< 0x7F End of Hardware Device Path.
 *
 *  UINT8 SubType;///< Varies by Type
 *                ///< 0xFF End Entire Device Path, or
 *                ///< 0x01 End This Instance of a Device Path and start a new
 *                ///< Device Path.
 *
 *  UINT8 Length[2];  ///< Specific Device Path data. Type and Sub-Type define
 *                    ///< type of data. Size of data is included in Length.
 *
 * } EFI_DEVICE_PATH_PROTOCOL;
 */
UINTN
NodeParser  (UINT8 *DevPath, UINTN PathSize, UINT8 Type)
{
  UINTN i;
  for (i=0; i<PathSize+1;){
    if (DevPath[i] == Type)
    {
      //This type corresponds to Type
      //So.. save position and exit from loop
      PathSize = i;
      break;
    }
    //Jump to the next device node type
    i += (((UINT16)DevPath[i+3]<<8) | DevPath[i+2]);
  }
  return PathSize;
}

BOOLEAN MetaiMatch (
                    IN CONST CHAR16   *String,
                    IN CONST CHAR16   *Pattern
                    );

/**
 This function converts an input device structure to a Unicode string.
 
 @param DevPath                  A pointer to the device path structure.
 
 @return A new allocated Unicode string that represents the device path.
 
 **/
CHAR16 *
EFIAPI
DevicePathToStr (
                 IN EFI_DEVICE_PATH_PROTOCOL     *DevPath
                 )
{
  return ConvertDevicePathToText (DevPath, TRUE, TRUE);
}



EFI_STATUS GetRootFromPath(IN EFI_DEVICE_PATH_PROTOCOL* DevicePath, OUT EFI_FILE **Root)
{
  EFI_STATUS  Status;
  EFI_HANDLE                NewHandle;
  EFI_DEVICE_PATH_PROTOCOL* TmpDevicePath;
  //  DBG(""Try to duplicate DevicePath\\n"");
  TmpDevicePath = DuplicateDevicePath(DevicePath);
  //  DBG(""TmpDevicePath found\\n"");
  NewHandle = NULL;
	Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid,
                                  &TmpDevicePath,
                                  &NewHandle);
  //   DBG(""volume handle found =%X\\n"", NewHandle);
  CheckError(Status, L""while reopening volume handle"");
  *Root = EfiLibOpenRoot(NewHandle);
  if (*Root == NULL) {
    //    DBG(""volume Root Dir can't be reopened\\n"");
    return EFI_NOT_FOUND;
  }
  if (FileExists(*Root, L""mach_kernel"")) {
    DBG(""mach_kernel exists\\n"");
  } else {
    DBG(""mach_kernel not exists\\n"");
  }
  
  return Status;
}
//
// self recognition stuff
//

EFI_STATUS InitRefitLib(IN EFI_HANDLE ImageHandle)
{
  EFI_STATUS  Status;
  CHAR16      *FilePathAsString;
  UINTN       i;
  UINTN                     DevicePathSize;
  EFI_DEVICE_PATH_PROTOCOL* TmpDevicePath;
  
  SelfImageHandle = ImageHandle;
  Status = gBS->HandleProtocol(SelfImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &SelfLoadedImage);
  if (CheckFatalError(Status, L""while getting a LoadedImageProtocol handle""))
    return Status;
  
  SelfDeviceHandle = SelfLoadedImage->DeviceHandle;
  TmpDevicePath = DevicePathFromHandle (SelfDeviceHandle);
  DevicePathSize = GetDevicePathSize (TmpDevicePath);
  SelfDevicePath = (__typeof__(SelfDevicePath))AllocateAlignedPages(EFI_SIZE_TO_PAGES(DevicePathSize), 64);
  CopyMem(SelfDevicePath, TmpDevicePath, DevicePathSize);
  
	DBG(""SelfDevicePath=%ls @%llX\\n"", FileDevicePathToStr(SelfDevicePath), (uintptr_t)SelfDeviceHandle);
  
  // find the current directory
  FilePathAsString = FileDevicePathToStr(SelfLoadedImage->FilePath);
  if (FilePathAsString != NULL) {
    SelfFullDevicePath = FileDevicePath(SelfDeviceHandle, FilePathAsString);
    for (i = StrLen(FilePathAsString); i > 0 && FilePathAsString[i] != '\\\\'; i--) ;
    if (i > 0) {
      FilePathAsString[i] = 0;
    } else {
      FilePathAsString[0] = L'\\\\';
      FilePathAsString[1] = 0;
    }
  } else {
    FilePathAsString = (__typeof__(FilePathAsString))AllocateCopyPool(StrSize(L""\\\\""), L""\\\\"");
  }
  SelfDirPath = FilePathAsString;
  
  DBG(""SelfDirPath = %ls\\n"", SelfDirPath);
  
  return FinishInitRefitLib();
}

VOID UninitRefitLib(VOID)
{
  // called before running external programs to close open file handles
  
  if (SelfDir != NULL) {
    SelfDir->Close(SelfDir);
    SelfDir = NULL;
  }
  
  if (OEMDir != NULL) {
    OEMDir->Close(OEMDir);
    OEMDir = NULL;
  }
  if (ThemeX.ThemeDir != NULL) {
    ThemeX.ThemeDir->Close(ThemeX.ThemeDir);
    ThemeX.ThemeDir = NULL;
  }


  if (SelfRootDir != NULL) {
    SelfRootDir->Close(SelfRootDir);
    SelfRootDir = NULL;
  }
  
  UninitVolumes();
}

EFI_STATUS ReinitRefitLib(VOID)
{
  // called after running external programs to re-open file handles
  //
  ReinitVolumes();
  
  if (SelfVolume != NULL && SelfVolume->RootDir != NULL)
    SelfRootDir = SelfVolume->RootDir;
  
  return FinishInitRefitLib();
}

EFI_STATUS ReinitSelfLib(VOID)
{
  // called after reconnect drivers to re-open file handles
  
  EFI_STATUS  Status;
  EFI_HANDLE                NewSelfHandle;
	EFI_DEVICE_PATH_PROTOCOL* TmpDevicePath;

//  DbgHeader(""ReinitSelfLib"");
  
  if (!SelfDevicePath) {
    return EFI_NOT_FOUND;
  }
  
  TmpDevicePath = DuplicateDevicePath(SelfDevicePath);
  DBG(""reinit: self device path=%ls\\n"", FileDevicePathToStr(TmpDevicePath));
  if(TmpDevicePath == NULL)
		return EFI_NOT_FOUND;
  
  NewSelfHandle = NULL;
	Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid,
                                  &TmpDevicePath,
                                  &NewSelfHandle);
  CheckError(Status, L""while reopening our self handle"");
	DBG(""new SelfHandle=%llX\\n"", (uintptr_t)NewSelfHandle);
  
  SelfRootDir = EfiLibOpenRoot(NewSelfHandle);
  if (SelfRootDir == NULL) {
    DBG(""SelfRootDir can't be reopened\\n"");
    return EFI_NOT_FOUND;
  }
  SelfDeviceHandle = NewSelfHandle;
  /*Status = */SelfRootDir->Open(SelfRootDir, &ThemeX.ThemeDir, ThemePath, EFI_FILE_MODE_READ, 0);


  /*Status = */SelfRootDir->Open(SelfRootDir, &OEMDir, OEMPath, EFI_FILE_MODE_READ, 0);
  Status = SelfRootDir->Open(SelfRootDir, &SelfDir, SelfDirPath, EFI_FILE_MODE_READ, 0);
  CheckFatalError(Status, L""while reopening our installation directory"");
  return Status;
}


static
EFI_STATUS FinishInitRefitLib(VOID)
{
	EFI_STATUS                Status;
  
  if (SelfRootDir == NULL) {
    SelfRootDir = EfiLibOpenRoot(SelfLoadedImage->DeviceHandle);
    if (SelfRootDir != NULL) {
      SelfDeviceHandle = SelfLoadedImage->DeviceHandle;
    } else {
      return EFI_LOAD_ERROR;
    }
  }
  /*Status = */SelfRootDir->Open(SelfRootDir, &ThemeX.ThemeDir, ThemePath, EFI_FILE_MODE_READ, 0);
  /*Status = */SelfRootDir->Open(SelfRootDir, &OEMDir, OEMPath, EFI_FILE_MODE_READ, 0);
  Status = SelfRootDir->Open(SelfRootDir, &SelfDir, SelfDirPath, EFI_FILE_MODE_READ, 0);
  CheckFatalError(Status, L""while opening our installation directory"");
  return Status;
}
BOOLEAN IsEmbeddedTheme()
{
  if (ThemeX.embedded) {
    ThemeX.ThemeDir = NULL;
  }
  return ThemeX.ThemeDir == NULL;
}



//
// firmware device path discovery
//

//looks like not used anywhere
static UINT8 LegacyLoaderMediaPathData[] = {
  0x04, 0x06, 0x14, 0x00, 0xEB, 0x85, 0x05, 0x2B,
  0xB8, 0xD8, 0xA9, 0x49, 0x8B, 0x8C, 0xE2, 0x1B,
  0x01, 0xAE, 0xF2, 0xB7, 0x7F, 0xFF, 0x04, 0x00,
};
static EFI_DEVICE_PATH *LegacyLoaderMediaPath = (EFI_DEVICE_PATH *)LegacyLoaderMediaPathData;

EFI_STATUS ExtractLegacyLoaderPaths(EFI_DEVICE_PATH **PathList, UINTN MaxPaths, EFI_DEVICE_PATH **HardcodedPathList)
{
  EFI_STATUS          Status;
  UINTN               HandleCount = 0;
  UINTN               HandleIndex, HardcodedIndex;
  EFI_HANDLE          *Handles = NULL;
  EFI_HANDLE          Handle;
  UINTN               PathCount = 0;
  UINTN               PathIndex;
  EFI_LOADED_IMAGE    *LoadedImage;
  EFI_DEVICE_PATH     *DevicePath;
  BOOLEAN             Seen;
  
  MaxPaths--;  // leave space for the terminating NULL pointer
  
  // get all LoadedImage handles
  Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiLoadedImageProtocolGuid, NULL,
                                   &HandleCount, &Handles);
  if (CheckError(Status, L""while listing LoadedImage handles"")) {
    if (HardcodedPathList) {
      for (HardcodedIndex = 0; HardcodedPathList[HardcodedIndex] && PathCount < MaxPaths; HardcodedIndex++)
        PathList[PathCount++] = HardcodedPathList[HardcodedIndex];
    }
    PathList[PathCount] = NULL;
    return Status;
  }
  for (HandleIndex = 0; HandleIndex < HandleCount && PathCount < MaxPaths; HandleIndex++) {
    Handle = Handles[HandleIndex];
    
    Status = gBS->HandleProtocol(Handle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage);
    if (EFI_ERROR(Status))
      continue;  // This can only happen if the firmware scewed up, ignore it.
    
    Status = gBS->HandleProtocol(LoadedImage->DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePath);
    if (EFI_ERROR(Status))
      continue;  // This happens, ignore it.
    
    // Only grab memory range nodes
    if (DevicePathType(DevicePath) != HARDWARE_DEVICE_PATH || DevicePathSubType(DevicePath) != HW_MEMMAP_DP)
      continue;
    
    // Check if we have this device path in the list already
    // WARNING: This assumes the first node in the device path is unique!
    Seen = FALSE;
    for (PathIndex = 0; PathIndex < PathCount; PathIndex++) {
      if (DevicePathNodeLength(DevicePath) != DevicePathNodeLength(PathList[PathIndex]))
        continue;
      if (CompareMem(DevicePath, PathList[PathIndex], DevicePathNodeLength(DevicePath)) == 0) {
        Seen = TRUE;
        break;
      }
    }
    if (Seen)
      continue;
    
    PathList[PathCount++] = AppendDevicePath(DevicePath, LegacyLoaderMediaPath);
  }
  FreePool(Handles);
  
  if (HardcodedPathList) {
    for (HardcodedIndex = 0; HardcodedPathList[HardcodedIndex] && PathCount < MaxPaths; HardcodedIndex++)
      PathList[PathCount++] = HardcodedPathList[HardcodedIndex];
  }
  PathList[PathCount] = NULL;
  return (PathCount > 0)?EFI_SUCCESS:EFI_NOT_FOUND;
}

//
// volume functions
//

static VOID ScanVolumeBootcode(IN OUT REFIT_VOLUME *Volume, OUT BOOLEAN *Bootable)
{
  EFI_STATUS              Status;
  UINT8                   *SectorBuffer;
  UINTN                   i;
  //MBR_PARTITION_INFO      *MbrTable;
  //BOOLEAN                 MbrTableFound;
  UINTN       BlockSize = 0;
  CHAR16      volumeName[255];
  CHAR8         tmp[64];
  UINT32        VCrc32;
  //  CHAR16      *kind = NULL;
  
  Volume->HasBootCode = FALSE;
  Volume->LegacyOS->IconName = NULL;
  Volume->LegacyOS->Name = NULL;
  //  Volume->BootType = BOOTING_BY_MBR; //default value
  Volume->BootType = BOOTING_BY_EFI;
  *Bootable = FALSE;
  
  if ((Volume->BlockIO == NULL) || (!Volume->BlockIO->Media->MediaPresent))
    return;
  ZeroMem((CHAR8*)&tmp[0], 64);
  BlockSize = Volume->BlockIO->Media->BlockSize;
  if (BlockSize > 2048)
    return;   // our buffer is too small... the bred of thieve of cable
  SectorBuffer = (__typeof__(SectorBuffer))AllocateAlignedPages(EFI_SIZE_TO_PAGES (2048), 16); //align to 16 byte?! Poher
  ZeroMem((CHAR8*)&SectorBuffer[0], 2048);
  // look at the boot sector (this is used for both hard disks and El Torito images!)
  Status = Volume->BlockIO->ReadBlocks(Volume->BlockIO, Volume->BlockIO->Media->MediaId,
                                       Volume->BlockIOOffset /*start lba*/,
                                       2048, SectorBuffer);
  if (!EFI_ERROR(Status) && (SectorBuffer[1] != 0)) {
    // calc crc checksum of first 2 sectors - it's used later for legacy boot BIOS drive num detection
    // note: possible future issues with AF 4K disks
    *Bootable = TRUE;
    Volume->HasBootCode = TRUE; //we assume that all CD are bootable
    /*      DBG(""check SectorBuffer\\n"");
     for (i=0; i<32; i++) {
     DBG(""%2hhX "", SectorBuffer[i]);
     }
     DBG(""\\n""); */
    VCrc32 = GetCrc32(SectorBuffer, 512 * 2);
    Volume->DriveCRC32 = VCrc32;
    //gBS->CalculateCrc32 (SectorBuffer, 2 * 512, &Volume->DriveCRC32);
    /*    switch (Volume->DiskKind ) {
     case DISK_KIND_OPTICAL:
     kind = L""DVD"";
     break;
     case DISK_KIND_INTERNAL:
     kind = L""HDD"";
     break;
     case DISK_KIND_EXTERNAL:
     kind = L""USB"";
     break;
     default:
     break;
     }
     DBG(""Volume kind=%ls CRC=0x%hhX\\n"", kind, VCrc32); */
    if (Volume->DiskKind == DISK_KIND_OPTICAL) { //CDROM
      CHAR8* p = (CHAR8*)&SectorBuffer[8];
      while (*p == 0x20) {
        p++;
      }
      for (i=0; i<30 && (*p >= 0x20) && (*p <= 'z'); i++, p++) {
        tmp[i] = *p;
      }
      tmp[i] = 0;
      while ((i>0) && (tmp[--i] == 0x20)) {}
      tmp[i+1] = 0;
			//	if (*p != 0) {
      AsciiStrToUnicodeStrS((CHAR8*)&tmp[0], volumeName, 255);
			//	}
      DBG(""Detected name %ls\\n"", volumeName);
      Volume->VolName = PoolPrint(L""%s"", volumeName);
      for (i=8; i<2000; i++) { //vendor search
        if (SectorBuffer[i] == 'A') {
          if (AsciiStrStr((CHAR8*)&SectorBuffer[i], ""APPLE"")) {
            //		StrCpy(Volume->VolName, volumeName);
            DBG(""        Found AppleDVD\\n"");
            Volume->LegacyOS->Type = OSTYPE_OSX;
            Volume->BootType = BOOTING_BY_CD;
            Volume->LegacyOS->IconName = L""mac"";
            break;
          }
        } else if (SectorBuffer[i] == 'M') {
          if (AsciiStrStr((CHAR8*)&SectorBuffer[i], ""MICROSOFT"")) {
            //		StrCpy(Volume->VolName, volumeName);
            DBG(""        Found Windows DVD\\n"");
            Volume->LegacyOS->Type = OSTYPE_WIN;
            Volume->BootType = BOOTING_BY_CD;
            Volume->LegacyOS->IconName = L""win"";
            break;
          }
          
        } else if (SectorBuffer[i] == 'L') {
          if (AsciiStrStr((CHAR8*)&SectorBuffer[i], ""LINUX"")) {
            //		Volume->DevicePath = DuplicateDevicePath(DevicePath);
            
            //		StrCpy(Volume->VolName, volumeName);
            DBG(""        Found Linux DVD\\n"");
            Volume->LegacyOS->Type = OSTYPE_LIN;
            Volume->BootType = BOOTING_BY_CD;
            Volume->LegacyOS->IconName = L""linux"";
            break;
          }
        }
      }
      
    }
    //else HDD
    else { //HDD
      /*
       // apianti - does this detect every partition as legacy?
       if (*((UINT16 *)(SectorBuffer + 510)) == 0xaa55 && SectorBuffer[0] != 0) {
       *Bootable = TRUE;
       Volume->HasBootCode = TRUE;
       //    DBG(""The volume has bootcode\\n"");
       Volume->LegacyOS->IconName = L""legacy"";
       Volume->LegacyOS->Name = L""Legacy"";
       Volume->LegacyOS->Type = OSTYPE_VAR;
       Volume->BootType = BOOTING_BY_PBR;
       }
       // */
      
      // detect specific boot codes
      if (CompareMem(SectorBuffer + 2, ""LILO"", 4) == 0 ||
          CompareMem(SectorBuffer + 6, ""LILO"", 4) == 0 ||
          CompareMem(SectorBuffer + 3, ""SYSLINUX"", 8) == 0 ||
          FindMem(SectorBuffer, 2048, ""ISOLINUX"", 8) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""linux"";
        Volume->LegacyOS->Name = L""Linux"";
        Volume->LegacyOS->Type = OSTYPE_LIN;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 512, ""Geom\\0Hard Disk\\0Read\\0 Error"", 26) >= 0) {   // GRUB
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""grub,linux"";
        Volume->LegacyOS->Name = L""Linux"";
        Volume->BootType = BOOTING_BY_PBR;
        /*
      } else if ((*((UINT32 *)(SectorBuffer)) == 0x4d0062e9 &&
                  *((UINT16 *)(SectorBuffer + 510)) == 0xaa55) ||
                 FindMem(SectorBuffer, 2048, ""BOOT      "", 10) >= 0) { //reboot Clover
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""clover"";
        Volume->LegacyOS->Name = L""Clover"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        //        DBG(""Detected Clover FAT32 bootcode\\n"");
     */   
        
      } else if ((*((UINT32 *)(SectorBuffer + 502)) == 0 &&
                  *((UINT32 *)(SectorBuffer + 506)) == 50000 &&
                  *((UINT16 *)(SectorBuffer + 510)) == 0xaa55) ||
                 FindMem(SectorBuffer, 2048, ""Starting the BTX loader"", 23) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""freebsd,linux"";
        Volume->LegacyOS->Name = L""FreeBSD"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        
        
      } else if (FindMem(SectorBuffer, 512, ""!Loading"", 8) >= 0 ||
                 FindMem(SectorBuffer, 2048, ""/cdboot\\0/CDBOOT\\0"", 16) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""openbsd,linux"";
        Volume->LegacyOS->Name = L""OpenBSD"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 512, ""Not a bootxx image"", 18) >= 0 ||
                 *((UINT32 *)(SectorBuffer + 1028)) == 0x7886b6d1) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""netbsd,linux"";
        Volume->LegacyOS->Name = L""NetBSD"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 2048, ""NTLDR"", 5) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""win"";
        Volume->LegacyOS->Name = L""Windows"";
        Volume->LegacyOS->Type = OSTYPE_WIN;
        Volume->BootType = BOOTING_BY_PBR;
        
        
      } else if (FindMem(SectorBuffer, 2048, ""BOOTMGR"", 7) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""vista,win"";
        Volume->LegacyOS->Name = L""Windows"";
        Volume->LegacyOS->Type = OSTYPE_WIN;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 512, ""CPUBOOT SYS"", 11) >= 0 ||
                 FindMem(SectorBuffer, 512, ""KERNEL  SYS"", 11) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""freedos,win"";
        Volume->LegacyOS->Name = L""FreeDOS"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
/*
      } else if (FindMem(SectorBuffer, 512, ""OS2LDR"", 6) >= 0 ||
                 FindMem(SectorBuffer, 512, ""OS2BOOT"", 7) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""ecomstation"";
        Volume->LegacyOS->Name = L""eComStation"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 512, ""Be Boot Loader"", 14) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""beos"";
        Volume->LegacyOS->Name = L""BeOS"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 512, ""yT Boot Loader"", 14) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""zeta"";
        Volume->LegacyOS->Name = L""ZETA"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
        
      } else if (FindMem(SectorBuffer, 512, ""\\x04"" ""beos\\x06"" ""system\\x05"" ""zbeos"", 18) >= 0 ||
                 FindMem(SectorBuffer, 512, ""haiku_loader"", 12) >= 0) {
        Volume->HasBootCode = TRUE;
        Volume->LegacyOS->IconName = L""haiku"";
        Volume->LegacyOS->Name = L""Haiku"";
        Volume->LegacyOS->Type = OSTYPE_VAR;
        Volume->BootType = BOOTING_BY_PBR;
 */
      } 
    }
    
    // NOTE: If you add an operating system with a name that starts with 'W' or 'L', you
    //  need to fix AddLegacyEntry in main.c.
    
#if REFIT_DEBUG > 0
    DBG(""        Result of bootcode detection: %ls %ls (%ls)\\n"",
        Volume->HasBootCode ? L""bootable"" : L""non-bootable"",
        Volume->LegacyOS->Name ? Volume->LegacyOS->Name: L""unknown"",
        Volume->LegacyOS->IconName ? Volume->LegacyOS->IconName: L""legacy"");
#endif

    if (FindMem(SectorBuffer, 512, ""Non-system disk"", 15) >= 0)   // dummy FAT boot sector
      Volume->HasBootCode = FALSE;

#ifdef JIEF_DEBUG
*Bootable = TRUE;
Volume->HasBootCode = TRUE;
Volume->LegacyOS->IconName = L""win"";
Volume->LegacyOS->Name = L""Windows"";
Volume->LegacyOS->Type = OSTYPE_WIN;
Volume->BootType = BOOTING_BY_PBR;
#endif

    // check for MBR partition table
    /*
     // apianti - this is littered with bugs and probably not needed lol
     if (*((UINT16 *)(SectorBuffer + 510)) == 0xaa55) {
     MbrTableFound = FALSE;
     MbrTable = (MBR_PARTITION_INFO *)(SectorBuffer + 446);
     for (i = 0; i < 4; i++)
     if (MbrTable[i].StartLBA && MbrTable[i].Size)
     MbrTableFound = TRUE;
     for (i = 0; i < 4; i++)
     if (MbrTable[i].Flags != 0x00 && MbrTable[i].Flags != 0x80)
     MbrTableFound = FALSE;
     if (MbrTableFound) {
     Volume->MbrPartitionTable = (__typeof__(Volume->MbrPartitionTable))AllocatePool(4 * 16);
     CopyMem(Volume->MbrPartitionTable, MbrTable, 4 * 16);
     Volume->BootType = BOOTING_BY_MBR;
     }
     }
     // */
  }
//  gBS->FreePages((EFI_PHYSICAL_ADDRESS)(UINTN)SectorBuffer, 1);
//  FreeAlignedPages((EFI_PHYSICAL_ADDRESS)(UINTN)SectorBuffer, 1);
  FreeAlignedPages((VOID*)SectorBuffer, EFI_SIZE_TO_PAGES (2048));
}

//at start we have only Volume->DeviceHandle
static EFI_STATUS ScanVolume(IN OUT REFIT_VOLUME *Volume)
{
  EFI_STATUS              Status;
  EFI_DEVICE_PATH         *DevicePath, *NextDevicePath;
  EFI_DEVICE_PATH         *DiskDevicePath, *RemainingDevicePath = NULL;
  HARDDRIVE_DEVICE_PATH   *HdPath     = NULL;
  EFI_HANDLE              WholeDiskHandle;
  UINTN                   PartialLength = 0;
  UINTN                   DevicePathSize;
  //  UINTN                   BufferSize = 255;
  EFI_FILE_SYSTEM_VOLUME_LABEL *VolumeInfo;
  EFI_FILE_SYSTEM_INFO    *FileSystemInfoPtr;
  EFI_FILE_INFO           *RootInfo = NULL;
  BOOLEAN                 Bootable;
  //  EFI_INPUT_KEY           Key;
  CHAR16                  *tmpName;
  
  // get device path
  DiskDevicePath = DevicePathFromHandle(Volume->DeviceHandle);
  DevicePathSize = GetDevicePathSize (DiskDevicePath);
  Volume->DevicePath = (__typeof__(Volume->DevicePath))AllocateAlignedPages(EFI_SIZE_TO_PAGES(DevicePathSize), 64);
  CopyMem(Volume->DevicePath, DiskDevicePath, DevicePathSize);
  Volume->DevicePathString = FileDevicePathToStr(Volume->DevicePath);
  
  //    Volume->DevicePath = DuplicateDevicePath(DevicePathFromHandle(Volume->DeviceHandle));
#if REFIT_DEBUG > 0
  if (Volume->DevicePath != NULL) {
    DBG("" %ls\\n"", FileDevicePathToStr(Volume->DevicePath));
//#if REFIT_DEBUG >= 2
    //       DumpHex(1, 0, GetDevicePathSize(Volume->DevicePath), Volume->DevicePath);
//#endif
  }
#else
    DBG(""\\n"");
#endif
  
  Volume->DiskKind = DISK_KIND_INTERNAL;  // default
  
  // get block i/o
  Status = gBS->HandleProtocol(Volume->DeviceHandle, &gEfiBlockIoProtocolGuid, (VOID **) &(Volume->BlockIO));
  if (EFI_ERROR(Status)) {
    Volume->BlockIO = NULL;
 //   DBG(""        Warning: Can't get BlockIO protocol.\\n"");
    //     WaitForSingleEvent (gST->ConIn->WaitForKey, 0);
    //     gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
    
    return Status;
  }
  
  Bootable = FALSE;
  if (Volume->BlockIO->Media->BlockSize == 2048){
//    DBG(""        Found optical drive\\n"");
    Volume->DiskKind = DISK_KIND_OPTICAL;
    Volume->BlockIOOffset = 0x10; // offset already applied for FS but not for blockio
    ScanVolumeBootcode(Volume, &Bootable);
  } else {
    //        DBG(""        Found HD drive\\n"");
    Volume->BlockIOOffset = 0;
    // scan for bootcode and MBR table
    ScanVolumeBootcode(Volume, &Bootable);
 //     DBG(""        ScanVolumeBootcode success\\n"");
    // detect device type
    DevicePath = DuplicateDevicePath(Volume->DevicePath);
    while (DevicePath != NULL && !IsDevicePathEndType(DevicePath)) {
      NextDevicePath = NextDevicePathNode(DevicePath);
      
      if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
          ((DevicePathSubType (DevicePath) == MSG_SATA_DP) ||
           (DevicePathSubType (DevicePath) == MSG_NVME_NAMESPACE_DP) ||
           (DevicePathSubType (DevicePath) == MSG_ATAPI_DP))) {
  //                  DBG(""        HDD volume\\n"");
            Volume->DiskKind = DISK_KIND_INTERNAL;
            break;
          }
      if (DevicePathType(DevicePath) == MESSAGING_DEVICE_PATH &&
          (DevicePathSubType(DevicePath) == MSG_USB_DP || DevicePathSubType(DevicePath) == MSG_USB_CLASS_DP)) {
   //     DBG(""        USB volume\\n"");
        Volume->DiskKind = DISK_KIND_EXTERNAL;
        //     break;
      }
      // FIREWIRE Devices
      if (DevicePathType(DevicePath) == MESSAGING_DEVICE_PATH &&
          (DevicePathSubType(DevicePath) == MSG_1394_DP || DevicePathSubType(DevicePath) == MSG_FIBRECHANNEL_DP)) {
        //        DBG(""        FireWire volume\\n"");
        Volume->DiskKind = DISK_KIND_FIREWIRE;
        break;
      }
      // CD-ROM Devices
      if (DevicePathType(DevicePath) == MEDIA_DEVICE_PATH &&
          DevicePathSubType(DevicePath) == MEDIA_CDROM_DP) {
        //        DBG(""        CD-ROM volume\\n"");
        Volume->DiskKind = DISK_KIND_OPTICAL;    //it's impossible
        break;
      }
      // VENDOR Specific Path
      if (DevicePathType(DevicePath) == MEDIA_DEVICE_PATH &&
          DevicePathSubType(DevicePath) == MEDIA_VENDOR_DP) {
  //              DBG(""        Vendor volume\\n"");
        Volume->DiskKind = DISK_KIND_NODISK;
        break;
      }
      // LEGACY CD-ROM
      if (DevicePathType(DevicePath) == BBS_DEVICE_PATH &&
          (DevicePathSubType(DevicePath) == BBS_BBS_DP || DevicePathSubType(DevicePath) == BBS_TYPE_CDROM)) {
        //        DBG(""        Legacy CD-ROM volume\\n"");
        Volume->DiskKind = DISK_KIND_OPTICAL;
        break;
      }
      // LEGACY HARDDISK
      if (DevicePathType(DevicePath) == BBS_DEVICE_PATH &&
          (DevicePathSubType(DevicePath) == BBS_BBS_DP || DevicePathSubType(DevicePath) == BBS_TYPE_HARDDRIVE)) {
  //              DBG(""        Legacy HDD volume\\n"");
        Volume->DiskKind = DISK_KIND_INTERNAL;
        break;
      }
      //one more we must take into account
      // subtype = MSG_NVME_NAMESPACE_DP
      // diskKind = NVME
      //#define MSG_NVME_NAMESPACE_DP     0x17
      
      DevicePath = NextDevicePath;
    }
    
    /*  what is the bread?
     // Bootable = TRUE;
     
     if (DevicePathType(DevicePath) == MEDIA_DEVICE_PATH &&
     DevicePathSubType(DevicePath) == MEDIA_VENDOR_DP) {
     Volume->IsAppleLegacy = TRUE;             // legacy BIOS device entry
     // TODO: also check for Boot Camp GUID
     //gEfiPartTypeSystemPartGuid
     Bootable = FALSE;   // this handle's BlockIO is just an alias for the whole device
     DBG(""AppleLegacy device\\n"");
     }
     */
  }
  
  
  DevicePath = DuplicateDevicePath(Volume->DevicePath);
  RemainingDevicePath = DevicePath; //initial value
	//
	// find the partition device path node
	//
	while (DevicePath && !IsDevicePathEnd (DevicePath)) {
		if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
        (DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)) {
      HdPath = (HARDDRIVE_DEVICE_PATH *)DevicePath;
      //			break;
		}
		DevicePath = NextDevicePathNode (DevicePath);
	}
//    DBG(""DevicePath scanned\\n"");
  if (HdPath) {
    //      printf(""Partition found %s\\n"", DevicePathToStr((EFI_DEVICE_PATH *)HdPath));
    
    PartialLength = (UINTN)((UINT8 *)HdPath - (UINT8 *)(RemainingDevicePath));
    if (PartialLength > 0x1000) {
      PartialLength = sizeof(EFI_DEVICE_PATH); //something wrong here but I don't want to be freezed
      //       return EFI_SUCCESS;
    }
    DiskDevicePath = (EFI_DEVICE_PATH *)AllocatePool(PartialLength + sizeof(EFI_DEVICE_PATH));
    CopyMem(DiskDevicePath, Volume->DevicePath, PartialLength);
    CopyMem((UINT8 *)DiskDevicePath + PartialLength, DevicePath, sizeof(EFI_DEVICE_PATH)); //EndDevicePath
  //        DBG(""WholeDevicePath  %ls\\n"", DevicePathToStr(DiskDevicePath));
    RemainingDevicePath = DiskDevicePath;
    Status = gBS->LocateDevicePath(&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &WholeDiskHandle);
    if (EFI_ERROR(Status)) {
      DBG(""Can't find WholeDevicePath: %s\\n"", strerror(Status));
    } else {
      Volume->WholeDiskDeviceHandle = WholeDiskHandle;
      Volume->WholeDiskDevicePath = DuplicateDevicePath(RemainingDevicePath);
      // look at the BlockIO protocol
      Status = gBS->HandleProtocol(WholeDiskHandle, &gEfiBlockIoProtocolGuid, (VOID **) &Volume->WholeDiskBlockIO);
      if (!EFI_ERROR(Status)) {
        //          DBG(""WholeDiskBlockIO %hhX BlockSize=%d\\n"", Volume->WholeDiskBlockIO, Volume->WholeDiskBlockIO->Media->BlockSize);
        // check the media block size
        if (Volume->WholeDiskBlockIO->Media->BlockSize == 2048)
          Volume->DiskKind = DISK_KIND_OPTICAL;
        
      } else {
        Volume->WholeDiskBlockIO = NULL;
      //  DBG(""no WholeDiskBlockIO: %s\\n"", strerror(Status));
        
        //CheckError(Status, L""from HandleProtocol"");
      }
    }
    FreePool(DiskDevicePath);
  }
  /*  else {
   DBG(""HD path is not found\\n""); //master volume!
   }*/
  
  //  if (GlobalConfig.FastBoot) {
  //    return EFI_SUCCESS;
  //  }
  
  if (!Bootable) {
#if REFIT_DEBUG > 0
    if (Volume->HasBootCode){
      DBG(""  Volume considered non-bootable, but boot code is present\\n"");
      //        WaitForSingleEvent (gST->ConIn->WaitForKey, 0);
      //        gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
    }
#endif
    Volume->HasBootCode = FALSE;
  }
  
  // open the root directory of the volume
  Volume->RootDir = EfiLibOpenRoot(Volume->DeviceHandle);
  //  DBG(""Volume->RootDir OK\\n"");
  if (Volume->RootDir == NULL) {
    //Print(L""Error: Can't open volume.\\n"");
    // TODO: signal that we had an error
    //Slice - there is LegacyBoot volume
    //properties are set before
    //    DBG(""LegacyBoot volume\\n"");
    
    if (HdPath) {
      tmpName = (CHAR16*)AllocateZeroPool(60);
      snwprintf(tmpName, 60, ""Legacy HD%d"", HdPath->PartitionNumber);
      Volume->VolName = EfiStrDuplicate(tmpName);
      FreePool(tmpName);
    } else if (!Volume->VolName) {
      Volume->VolName =  EfiStrDuplicate(L""Whole Disc Boot"");
    }
    if (!Volume->LegacyOS->IconName)
      Volume->LegacyOS->IconName = EfiStrDuplicate(L""legacy"");
    
    return EFI_SUCCESS;
  }
  
  if ( FileExists(Volume->RootDir, L""\\\\.VolumeLabel.txt"") ) {
      EFI_FILE_HANDLE     FileHandle;
      Status = Volume->RootDir->Open(Volume->RootDir, &FileHandle, L""\\\\.VolumeLabel.txt"", EFI_FILE_MODE_READ, 0);
      if (!EFI_ERROR(Status)) {
          CHAR8 Buffer[32+1];
          UINTN BufferSize = sizeof(Buffer)-sizeof(CHAR8);
          SetMem(Buffer, BufferSize+sizeof(CHAR8), 0);
          Status = FileHandle->Read(FileHandle, &BufferSize, Buffer);
          FileHandle->Close(FileHandle);
          if (!EFI_ERROR(Status)) {
                // strip line endings
                while (BufferSize > 0 && (Buffer[BufferSize-1]=='\\n' || Buffer[BufferSize-1]=='\\r')) {
                  Buffer[--BufferSize]='\\0';
                }
          	Volume->VolLabel = PoolPrint(L""%a"", Buffer);
          }
      }
  }
  
  // get volume name
  if (!Volume->VolName) {
    FileSystemInfoPtr = EfiLibFileSystemInfo(Volume->RootDir);
    if (FileSystemInfoPtr) {
      //DBG(""  Volume name from FileSystem: '%ls'\\n"", FileSystemInfoPtr->VolumeLabel);
      Volume->VolName = EfiStrDuplicate(FileSystemInfoPtr->VolumeLabel);
      FreePool(FileSystemInfoPtr);
    }
  }
  if (!Volume->VolName) {
    VolumeInfo = EfiLibFileSystemVolumeLabelInfo(Volume->RootDir);
    if (VolumeInfo) {
      //DBG(""  Volume name from VolumeLabel: '%ls'\\n"", VolumeInfo->VolumeLabel);
      Volume->VolName = EfiStrDuplicate(VolumeInfo->VolumeLabel);
      FreePool(VolumeInfo);
    }
  }
  if (!Volume->VolName) {
    RootInfo = EfiLibFileInfo (Volume->RootDir);
    if (RootInfo) {
      //DBG(""  Volume name from RootFile: '%ls'\\n"", RootInfo->FileName);
      Volume->VolName = EfiStrDuplicate(RootInfo->FileName);
      FreePool(RootInfo);
    }
  }
  if (
      Volume->VolName == NULL
      || Volume->VolName[0] == 0
      || (Volume->VolName[0] == L'\\\\' && Volume->VolName[1] == 0)
      || (Volume->VolName[0] == L'/' && Volume->VolName[1] == 0)
      )
  {
    VOID *Instance;
    if (!EFI_ERROR(gBS->HandleProtocol(Volume->DeviceHandle, &gEfiPartTypeSystemPartGuid, &Instance))) {
      Volume->VolName = L""EFI"";                                 \\
    }
  }
  if (!Volume->VolName) {
//    DBG(""Create unknown name\\n"");
    //        WaitForSingleEvent (gST->ConIn->WaitForKey, 0);
    //        gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
    
    if (HdPath) {
      
      tmpName = (CHAR16*)AllocateZeroPool(128);
      snwprintf(tmpName, 128, ""Unknown HD%d"", HdPath->PartitionNumber);
      Volume->VolName = EfiStrDuplicate(tmpName);
      FreePool(tmpName);
      // NOTE: this is normal for Apple's VenMedia device paths
    } else {
      Volume->VolName = EfiStrDuplicate(L""Unknown HD""); //To be able to free it
    }
  }
  
  //Status = GetOSVersion(Volume); NOTE: Sothor - We will find icon names later once we have found boot.efi on the volume //here we set Volume->IconName (tiger,leo,snow,lion,cougar, etc)
  
  return EFI_SUCCESS;
}

static VOID ScanExtendedPartition(REFIT_VOLUME *WholeDiskVolume, MBR_PARTITION_INFO *MbrEntry)
{
  EFI_STATUS              Status;
  REFIT_VOLUME            *Volume;
  UINT32                  ExtBase, ExtCurrent, NextExtCurrent;
  UINTN                   i;
  UINTN                   LogicalPartitionIndex = 4;
  UINT8                   *SectorBuffer;
  BOOLEAN                 Bootable;
  MBR_PARTITION_INFO      *EMbrTable;
  
  ExtBase = MbrEntry->StartLBA;
  SectorBuffer = (__typeof__(SectorBuffer))AllocateAlignedPages (EFI_SIZE_TO_PAGES (512), WholeDiskVolume->BlockIO->Media->IoAlign);
  
  for (ExtCurrent = ExtBase; ExtCurrent; ExtCurrent = NextExtCurrent) {
    // read current EMBR
    Status = WholeDiskVolume->BlockIO->ReadBlocks(WholeDiskVolume->BlockIO,
                                                  WholeDiskVolume->BlockIO->Media->MediaId,
                                                  ExtCurrent, 512, SectorBuffer);
    if (EFI_ERROR(Status))
      break;
    if (*((UINT16 *)(SectorBuffer + 510)) != 0xaa55)
      break;
    EMbrTable = (MBR_PARTITION_INFO *)(SectorBuffer + 446);
    
    // scan logical partitions in this EMBR
    NextExtCurrent = 0;
    for (i = 0; i < 4; i++) {
      if ((EMbrTable[i].Flags != 0x00 && EMbrTable[i].Flags != 0x80) ||
          EMbrTable[i].StartLBA == 0 || EMbrTable[i].Size == 0)
        break;
      if (IS_EXTENDED_PART_TYPE(EMbrTable[i].Type)) {
        // set next ExtCurrent
        NextExtCurrent = ExtBase + EMbrTable[i].StartLBA;
        break;
      } else {
        
        // found a logical partition
        Volume = (__typeof__(Volume))AllocateZeroPool(sizeof(*Volume));
        Volume->DiskKind = WholeDiskVolume->DiskKind;
        Volume->IsMbrPartition = TRUE;
        Volume->MbrPartitionIndex = LogicalPartitionIndex++;
        Volume->VolName = PoolPrint(L""Partition %d"", Volume->MbrPartitionIndex + 1);
        Volume->BlockIO = WholeDiskVolume->BlockIO;
        Volume->BlockIOOffset = ExtCurrent + EMbrTable[i].StartLBA;
        Volume->WholeDiskBlockIO = WholeDiskVolume->BlockIO;
        Volume->WholeDiskDeviceHandle = WholeDiskVolume->DeviceHandle;
        
        Bootable = FALSE;
        ScanVolumeBootcode(Volume, &Bootable);
        if (!Bootable)
          Volume->HasBootCode = FALSE;
        
        Volumes.AddReference(Volume, false);
//        AddListElement((VOID ***) &Volumes, &VolumesCount, Volume);
      }
    }
  }
  gBS->FreePages((EFI_PHYSICAL_ADDRESS)(UINTN)SectorBuffer, 1);
}

VOID ScanVolumes(VOID)
{
  EFI_STATUS              Status;
  UINTN                   HandleCount = 0;
  UINTN                   HandleIndex;
  EFI_HANDLE              *Handles = NULL;
  REFIT_VOLUME            *WholeDiskVolume;
  UINTN                   VolumeIndex, VolumeIndex2;
  MBR_PARTITION_INFO      *MbrTable;
  UINTN                   PartitionIndex;
  UINT8                   *SectorBuffer1, *SectorBuffer2;
  UINTN                   SectorSum, i;
  //  EFI_DEVICE_PATH_PROTOCOL  *VolumeDevicePath;
  //  EFI_GUID                *Guid; //for debug only
  //  EFI_INPUT_KEY Key;
  INT32                   HVi;
  
  //    DBG(""Scanning volumes...\\n"");
  DbgHeader(""ScanVolumes"");
  
  // get all BlockIo handles
  Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &HandleCount, &Handles);
  if (Status == EFI_NOT_FOUND)
    return;
	DBG(""Found %llu volumes with blockIO\\n"", HandleCount);
  // first pass: collect information about all handles
  for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
    
    REFIT_VOLUME* Volume = (__typeof__(Volume))AllocateZeroPool(sizeof(*Volume));
    Volume->LegacyOS = (__typeof__(Volume->LegacyOS))AllocateZeroPool(sizeof(LEGACY_OS));
    Volume->DeviceHandle = Handles[HandleIndex];
    if (Volume->DeviceHandle == SelfDeviceHandle) {
      SelfVolume = Volume;
    }
    
	  DBG(""- [%02llu]: Volume:"", HandleIndex);
    
    Volume->Hidden = FALSE; // default to not hidden
    
    Status = ScanVolume(Volume);
    if (!EFI_ERROR(Status)) {
      Volumes.AddReference(Volume, false);
//      AddListElement((VOID ***) &Volumes, &VolumesCount, Volume);
      if (!gSettings.ShowHiddenEntries) {
        for (HVi = 0; HVi < gSettings.HVCount; HVi++) {
          if (StriStr(Volume->DevicePathString, gSettings.HVHideStrings[HVi]) ||
              (Volume->VolName != NULL && StriStr(Volume->VolName, gSettings.HVHideStrings[HVi]))) {
            Volume->Hidden = TRUE;
            DBG(""        hiding this volume\\n"");
            break;
          }
        }
      }
      
//      Guid = FindGPTPartitionGuidInDevicePath(Volume->DevicePath);
      if (!Volume->LegacyOS->IconName) {
        Volume->LegacyOS->IconName = L""legacy"";
      }
//      DBG(""  Volume '%ls', LegacyOS '%ls', LegacyIcon(s) '%ls', GUID = %s\\n"",
//          Volume->VolName, Volume->LegacyOS->Name ? Volume->LegacyOS->Name : L"""", Volume->LegacyOS->IconName, strguid(Guid));
      if (SelfVolume == Volume) {
        DBG(""        This is SelfVolume !!\\n"");
      }
      
    } else {
		DBG(""        wrong volume Nr%llu?!\\n"", HandleIndex);
      FreePool(Volume);
    }
  }
  FreePool(Handles);
  //  DBG(""Found %d volumes\\n"", VolumesCount);
  if (SelfVolume == NULL){
    DBG(""        WARNING: SelfVolume not found""); //Slice - and what?
    SelfVolume = (__typeof__(SelfVolume))AllocateZeroPool(sizeof(REFIT_VOLUME));
    SelfVolume->DeviceHandle = SelfDeviceHandle;
    SelfVolume->DevicePath = SelfDevicePath;
    SelfVolume->RootDir = SelfRootDir;
    SelfVolume->DiskKind = DISK_KIND_BOOTER;
    SelfVolume->VolName = L""Clover"";
    SelfVolume->LegacyOS->Type = OSTYPE_EFI;
    SelfVolume->HasBootCode = TRUE;
    SelfVolume->BootType = BOOTING_BY_PBR;
    //   AddListElement((VOID ***) &Volumes, &VolumesCount, SelfVolume);
    //    DBG(""SelfVolume Nr %d created\\n"", VolumesCount);
  }
  
  // second pass: relate partitions and whole disk devices
  for (VolumeIndex = 0; VolumeIndex < Volumes.size(); VolumeIndex++) {
    REFIT_VOLUME* Volume = &Volumes[VolumeIndex];
    
    // check MBR partition table for extended partitions
    if (Volume->BlockIO != NULL && Volume->WholeDiskBlockIO != NULL &&
        Volume->BlockIO == Volume->WholeDiskBlockIO && Volume->BlockIOOffset == 0 &&
        Volume->MbrPartitionTable != NULL) {
		DBG(""        Volume %llu has MBR\\n"", VolumeIndex);
      MbrTable = Volume->MbrPartitionTable;
      for (PartitionIndex = 0; PartitionIndex < 4; PartitionIndex++) {
        if (IS_EXTENDED_PART_TYPE(MbrTable[PartitionIndex].Type)) {
          ScanExtendedPartition(Volume, MbrTable + PartitionIndex);
        }
      }
    }
    
    // search for corresponding whole disk volume entry
    WholeDiskVolume = NULL;
    if (Volume->BlockIO != NULL && Volume->WholeDiskBlockIO != NULL &&
        Volume->BlockIO != Volume->WholeDiskBlockIO) {
      for (VolumeIndex2 = 0; VolumeIndex2 < Volumes.size(); VolumeIndex2++) {
        if (Volumes[VolumeIndex2].BlockIO == Volume->WholeDiskBlockIO &&
            Volumes[VolumeIndex2].BlockIOOffset == 0)
          WholeDiskVolume = &Volumes[VolumeIndex2];
      }
    }
    if (WholeDiskVolume != NULL && WholeDiskVolume->MbrPartitionTable != NULL) {
      // check if this volume is one of the partitions in the table
      MbrTable = WholeDiskVolume->MbrPartitionTable;
      SectorBuffer1 = (__typeof__(SectorBuffer1))AllocateAlignedPages (EFI_SIZE_TO_PAGES (512), 16);
      SectorBuffer2 = (__typeof__(SectorBuffer2))AllocateAlignedPages (EFI_SIZE_TO_PAGES (512), 16);
      
      for (PartitionIndex = 0; PartitionIndex < 4; PartitionIndex++) {
        // check size
        if ((UINT64)(MbrTable[PartitionIndex].Size) != Volume->BlockIO->Media->LastBlock + 1)
          continue;
        
        // compare boot sector read through offset vs. directly
        Status = Volume->BlockIO->ReadBlocks(Volume->BlockIO, Volume->BlockIO->Media->MediaId,
                                             Volume->BlockIOOffset, 512, SectorBuffer1);
        if (EFI_ERROR(Status))
          break;
        Status = Volume->WholeDiskBlockIO->ReadBlocks(Volume->WholeDiskBlockIO, Volume->WholeDiskBlockIO->Media->MediaId,
                                                      MbrTable[PartitionIndex].StartLBA, 512, SectorBuffer2);
        if (EFI_ERROR(Status))
          break;
        if (CompareMem(SectorBuffer1, SectorBuffer2, 512) != 0)
          continue;
        SectorSum = 0;
        for (i = 0; i < 512; i++)
          SectorSum += SectorBuffer1[i];
        if (SectorSum < 1000)
          continue;
        
        // TODO: mark entry as non-bootable if it is an extended partition
        
        // now we're reasonably sure the association is correct...
        Volume->IsMbrPartition = TRUE;
        Volume->MbrPartitionTable = MbrTable;
        Volume->MbrPartitionIndex = PartitionIndex;
        if (Volume->VolName == NULL)
          Volume->VolName = PoolPrint(L""Partition %d"", PartitionIndex + 1);
        break;
      }
      
      gBS->FreePages((EFI_PHYSICAL_ADDRESS)(UINTN)SectorBuffer1, 1);
      gBS->FreePages((EFI_PHYSICAL_ADDRESS)(UINTN)SectorBuffer2, 1);
    }
    
  }
}

static VOID UninitVolumes(VOID)
{
  REFIT_VOLUME            *Volume;
  UINTN                   VolumeIndex;
  
  for (VolumeIndex = 0; VolumeIndex < Volumes.size(); VolumeIndex++) {
    Volume = &Volumes[VolumeIndex];
    
    if (Volume->RootDir != NULL) {
      Volume->RootDir->Close(Volume->RootDir);
      Volume->RootDir = NULL;
    }
    
    Volume->DeviceHandle = NULL;
    Volume->BlockIO = NULL;
    Volume->WholeDiskBlockIO = NULL;
    Volume->WholeDiskDeviceHandle = NULL;
    FreePool(Volume);
  }
  Volumes.Empty();
}

VOID ReinitVolumes(VOID)
{
  EFI_STATUS              Status;
  REFIT_VOLUME            *Volume;
  UINTN                   VolumeIndex;
  UINTN           VolumesFound = 0;
  EFI_DEVICE_PATH         *RemainingDevicePath;
  EFI_HANDLE              DeviceHandle, WholeDiskHandle;
  
  for (VolumeIndex = 0; VolumeIndex < Volumes.size(); VolumeIndex++) {
    Volume = &Volumes[VolumeIndex];
    if (!Volume) {
      continue;
    }
	  DBG(""Volume %llu at reinit found:\\n"", VolumeIndex);
    DBG(""Volume->DevicePath=%ls\\n"", FileDevicePathToStr(Volume->DevicePath));
    VolumesFound++;
    if (Volume->DevicePath != NULL) {
      // get the handle for that path
      RemainingDevicePath = Volume->DevicePath;
      Status = gBS->LocateDevicePath(&gEfiBlockIoProtocolGuid, &RemainingDevicePath, &DeviceHandle);
      
      if (!EFI_ERROR(Status)) {
        Volume->DeviceHandle = DeviceHandle;
        
        // get the root directory
        Volume->RootDir = EfiLibOpenRoot(Volume->DeviceHandle);
        
      }
      //else
      //  CheckError(Status, L""from LocateDevicePath"");
    }
    
    if (Volume->WholeDiskDevicePath != NULL) {
      // get the handle for that path
      RemainingDevicePath = DuplicateDevicePath(Volume->WholeDiskDevicePath);
      Status = gBS->LocateDevicePath(&gEfiBlockIoProtocolGuid, &RemainingDevicePath, &WholeDiskHandle);
      
      if (!EFI_ERROR(Status)) {
        Volume->WholeDiskBlockIO = (__typeof__(Volume->WholeDiskBlockIO))WholeDiskHandle;
        // get the BlockIO protocol
        Status = gBS->HandleProtocol(WholeDiskHandle, &gEfiBlockIoProtocolGuid, (VOID **) &Volume->WholeDiskBlockIO);
        if (EFI_ERROR(Status)) {
          Volume->WholeDiskBlockIO = NULL;
          CheckError(Status, L""from HandleProtocol"");
        }
      }
      //else
      //  CheckError(Status, L""from LocateDevicePath"");
    }
  }
// Jief : I'm not sure to understand the next line. Why would we change the count when we didn't change the array.
// This code is not currently not used.
// Beware if you want to reuse this.
//  VolumesCount = VolumesFound;
}

REFIT_VOLUME *FindVolumeByName(IN CHAR16 *VolName)
{
  REFIT_VOLUME            *Volume;
  UINTN                   VolumeIndex;
  
  if (!VolName) {
    return NULL;
  }
  
  for (VolumeIndex = 0; VolumeIndex < Volumes.size(); VolumeIndex++) {
    Volume = &Volumes[VolumeIndex];
    if (!Volume) {
      continue;
    }
    if (Volume->VolName && StrCmp(Volume->VolName,VolName) == 0) {
      return Volume;
    }
  }
  
  return NULL;
}

//
// file and dir functions
//

BOOLEAN FileExists(IN CONST EFI_FILE *Root, IN CONST CHAR16 *RelativePath)
{
  EFI_STATUS  Status;
  EFI_FILE    *TestFile = NULL;
  
  Status = Root->Open(Root, &TestFile, RelativePath, EFI_FILE_MODE_READ, 0);
  if (Status == EFI_SUCCESS) {
    if (TestFile && TestFile->Close) {
      TestFile->Close(TestFile);
    }
    return TRUE;
  }
  return FALSE;
}

BOOLEAN FileExists(IN CONST EFI_FILE *Root, IN CONST XStringW& RelativePath)
{
	return FileExists(Root, RelativePath.wc_str());
}

BOOLEAN DeleteFile(IN EFI_FILE *Root, IN CONST CHAR16 *RelativePath)
{
  EFI_STATUS  Status;
  EFI_FILE    *File;
  EFI_FILE_INFO   *FileInfo;
  
  //DBG(""DeleteFile: %ls\\n"", RelativePath);
  // open file for read/write to see if it exists, need write for delete
  Status = Root->Open(Root, &File, RelativePath, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE, 0);
  //DBG("" Open: %s\\n"", strerror(Status));
  if (Status == EFI_SUCCESS) {
    // exists - check if it is a file
    FileInfo = EfiLibFileInfo(File);
    if (FileInfo == NULL) {
      // error
      //DBG("" FileInfo is NULL\\n"");
      File->Close(File);
      return FALSE;
    }
    //DBG("" FileInfo attr: %hhX\\n"", FileInfo->Attribute);
    if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
      // it's directory - return error
      //DBG("" File is DIR\\n"");
      FreePool(FileInfo);
      File->Close(File);
      return FALSE;
    }
    FreePool(FileInfo);
    // it's a file - delete it
    //DBG("" File is file\\n"");
    Status = File->Delete(File);
    //DBG("" Delete: %s\\n"", strerror(Status));
    
    return Status == EFI_SUCCESS;
  }
  return FALSE;
}

EFI_STATUS DirNextEntry(IN EFI_FILE *Directory, IN OUT EFI_FILE_INFO **DirEntry, IN UINTN FilterMode)
{
  EFI_STATUS Status;
  VOID *Buffer;
  UINTN LastBufferSize, BufferSize;
  INTN IterCount;
  
  for (;;) {
    
    // free pointer from last call
    if (*DirEntry != NULL) {
      FreePool(*DirEntry);
      *DirEntry = NULL;
    }
    
    // read next directory entry
    LastBufferSize = BufferSize = 256;
    Buffer = (__typeof__(Buffer))AllocateZeroPool(BufferSize);
    for (IterCount = 0; ; IterCount++) {
      Status = Directory->Read(Directory, &BufferSize, Buffer);
      if (Status != EFI_BUFFER_TOO_SMALL || IterCount >= 4)
        break;
      if (BufferSize <= LastBufferSize) {
		  DBG(""FS Driver requests bad buffer size %llu (was %llu), using %llu instead\\n"", BufferSize, LastBufferSize, LastBufferSize * 2);
        BufferSize = LastBufferSize * 2;
#if REFIT_DEBUG > 0
      } else {
		  DBG(""Reallocating buffer from %llu to %llu\\n"", LastBufferSize, BufferSize);
#endif
      }
      Buffer = (__typeof__(Buffer))EfiReallocatePool(Buffer, LastBufferSize, BufferSize);
      LastBufferSize = BufferSize;
    }
    if (EFI_ERROR(Status)) {
      FreePool(Buffer);
      break;
    }
    
    // check for end of listing
    if (BufferSize == 0) {    // end of directory listing
      FreePool(Buffer);
      break;
    }
    
    // entry is ready to be returned
    *DirEntry = (EFI_FILE_INFO *)Buffer;
    if (*DirEntry) {
      // filter results
      if (FilterMode == 1) {   // only return directories
        if (((*DirEntry)->Attribute & EFI_FILE_DIRECTORY))
          break;
      } else if (FilterMode == 2) {   // only return files
        if (((*DirEntry)->Attribute & EFI_FILE_DIRECTORY) == 0)
          break;
      } else                   // no filter or unknown filter -> return everything
        break;
    }
  }
  return Status;
}

VOID DirIterOpen(IN EFI_FILE *BaseDir, IN CONST CHAR16 *RelativePath OPTIONAL, OUT REFIT_DIR_ITER *DirIter)
{
  if (RelativePath == NULL) {
    DirIter->LastStatus = EFI_SUCCESS;
    DirIter->DirHandle = BaseDir;
    DirIter->CloseDirHandle = FALSE;
  } else {
    DirIter->LastStatus = BaseDir->Open(BaseDir, &(DirIter->DirHandle), RelativePath, EFI_FILE_MODE_READ, 0);
    DirIter->CloseDirHandle = EFI_ERROR(DirIter->LastStatus) ? FALSE : TRUE;
  }
  DirIter->LastFileInfo = NULL;
}

BOOLEAN DirIterNext(IN OUT REFIT_DIR_ITER *DirIter, IN UINTN FilterMode, IN CONST CHAR16 *FilePattern OPTIONAL,
                    OUT EFI_FILE_INFO **DirEntry)
{
  if (DirIter->LastFileInfo != NULL) {
    FreePool(DirIter->LastFileInfo);
    DirIter->LastFileInfo = NULL;
  }
  
  if (EFI_ERROR(DirIter->LastStatus))
    return FALSE;   // stop iteration
  
  for (;;) {
    DirIter->LastStatus = DirNextEntry(DirIter->DirHandle, &(DirIter->LastFileInfo), FilterMode);
    if (EFI_ERROR(DirIter->LastStatus))
      return FALSE;
    if (DirIter->LastFileInfo == NULL)  // end of listing
      return FALSE;
    if (FilePattern != NULL) {
      if ((DirIter->LastFileInfo->Attribute & EFI_FILE_DIRECTORY))
        break;
      if (MetaiMatch(DirIter->LastFileInfo->FileName, FilePattern))
        break;
      // else continue loop
    } else
      break;
  }
  
  *DirEntry = DirIter->LastFileInfo;
  return TRUE;
}

EFI_STATUS DirIterClose(IN OUT REFIT_DIR_ITER *DirIter)
{
  if (DirIter->LastFileInfo != NULL) {
    FreePool(DirIter->LastFileInfo);
    DirIter->LastFileInfo = NULL;
  }
  if (DirIter->CloseDirHandle)
    DirIter->DirHandle->Close(DirIter->DirHandle);
  return DirIter->LastStatus;
}

//
// file name manipulation
//
BOOLEAN
MetaiMatch (
            IN CONST CHAR16   *String,
            IN CONST CHAR16   *Pattern
            )
{
	if (!mUnicodeCollation) {
		// quick fix for driver loading on UEFIs without UnicodeCollation
		//return FALSE;
		return TRUE; //this is wrong anyway
	}
	return mUnicodeCollation->MetaiMatch (mUnicodeCollation, String, Pattern);
}


EFI_STATUS
InitializeUnicodeCollationProtocol (VOID)
{
	EFI_STATUS  Status;
	
	if (mUnicodeCollation != NULL) {
		return EFI_SUCCESS;
	}
	
	//
	// BUGBUG: Proper impelmentation is to locate all Unicode Collation Protocol
	// instances first and then select one which support English language.
	// Current implementation just pick the first instance.
	//
	Status = gBS->LocateProtocol (
                                &gEfiUnicodeCollation2ProtocolGuid,
                                NULL,
                                (VOID **) &mUnicodeCollation
                                );
  if (EFI_ERROR(Status)) {
    Status = gBS->LocateProtocol (
                                  &gEfiUnicodeCollationProtocolGuid,
                                  NULL,
                                  (VOID **) &mUnicodeCollation
                                  );
    
  }
	return Status;
}



CONST CHAR16 * Basename(IN CONST CHAR16 *Path)
{
  CONST CHAR16  *FileName;
  UINTN   i;
  
  FileName = Path;
  
  if (Path != NULL) {
    for (i = StrLen(Path); i > 0; i--) {
      if (Path[i-1] == '\\\\' || Path[i-1] == '/') {
        FileName = Path + i;
        break;
      }
    }
  }
  
  return FileName;
}

VOID ReplaceExtension(IN OUT CHAR16 *Path, IN CHAR16 *Extension)
{
  INTN i;
  
  for (i = StrLen(Path); i >= 0; i--) {
    if (Path[i] == '.') {
      Path[i] = 0;
      break;
    }
    if (Path[i] == '\\\\' || Path[i] == '/')
      break;
  }
  StrCatS(Path, StrLen(Path)/sizeof(CHAR16)+1, Extension);
}

CHAR16 * egFindExtension(IN CHAR16 *FileName)
{
    INTN i;

    for (i = StrLen(FileName); i >= 0; i--) {
        if (FileName[i] == '.')
            return FileName + i + 1;
        if (FileName[i] == '/' || FileName[i] == '\\\\')
            break;
    }
    return FileName + StrLen(FileName);
}

//
// memory string search
//

INTN FindMem(IN CONST VOID *Buffer, IN UINTN BufferLength, IN CONST VOID *SearchString, IN UINTN SearchStringLength)
{
  CONST UINT8 *BufferPtr;
  UINTN Offset;
  
  BufferPtr = (CONST UINT8 *)Buffer;
  BufferLength -= SearchStringLength;
  for (Offset = 0; Offset < BufferLength; Offset++, BufferPtr++) {
    if (CompareMem(BufferPtr, SearchString, SearchStringLength) == 0)
      return (INTN)Offset;
  }
  
  return -1;
}

//
// Aptio UEFI returns File DevPath as 2 nodes (dir, file)
// and DevicePathToStr connects them with /, but we need '\\\\'
CHAR16 *FileDevicePathToStr(IN EFI_DEVICE_PATH_PROTOCOL *DevPath)
{
  CHAR16      *FilePath;
  CHAR16      *Char;
  CONST CHAR16      *Tail;
  
  FilePath = DevicePathToStr(DevPath);
  // fix / into '\\\\'
  if (FilePath != NULL) {
    for (Char = FilePath; *Char != L'\\0'; Char++) {
      if (*Char == L'/') {
        *Char = L'\\\\';
      }
    }
  }
  // ""\\\\\\\\"" into '\\\\'
  Char = (CHAR16*)StrStr(FilePath, L""\\\\\\\\""); // cast is ok because FilePath is not const, and we know that StrStr returns a pointer in FilePath. Will disappear when using a string object instead of CHAR16*
  while (Char != NULL) {
//    StrCpyS(Char, 4, Char + 1);  //can't overlap
    Tail = Char + 1;
    while (*Char != 0) {
      *(Char++) = *(Tail++);
    }
    Char = (CHAR16*)StrStr(FilePath, L""\\\\\\\\""); // cast is ok because FilePath is not const, and we know that StrStr returns a pointer in FilePath. Will disappear when using a string object instead of CHAR16*
  }
  return FilePath;
}

CHAR16 *FileDevicePathFileToStr(IN EFI_DEVICE_PATH_PROTOCOL *DevPath)
{
  EFI_DEVICE_PATH_PROTOCOL *Node;
  
  if (DevPath == NULL) {
    return NULL;
  }
  
  Node = (EFI_DEVICE_PATH_PROTOCOL *)DevPath;
  while (!IsDevicePathEnd(Node)) {
    if ((Node->Type == MEDIA_DEVICE_PATH) &&
        (Node->SubType == MEDIA_FILEPATH_DP)) {
      return FileDevicePathToStr(Node);
    }
    Node = NextDevicePathNode(Node);
  }
  return NULL;
}

BOOLEAN DumpVariable(CHAR16* Name, EFI_GUID* Guid, INTN DevicePathAt)
{
  UINTN                     dataSize            = 0;
  UINT8                     *data               = NULL;
  UINTN i;
  EFI_STATUS  Status;
  
  Status = gRT->GetVariable (Name, Guid, NULL, &dataSize, data);
  if (Status == EFI_BUFFER_TOO_SMALL) {
    data = (__typeof__(data))AllocateZeroPool(dataSize);
    Status = gRT->GetVariable (Name, Guid, NULL, &dataSize, data);
    if (EFI_ERROR(Status)) {
		DBG(""Can't get %ls, size=%llu\\n"", Name, dataSize);
      FreePool(data);
      data = NULL;
    } else {
		DBG(""%ls var size=%llu\\n"", Name, dataSize);
      for (i = 0; i < dataSize; i++) {
        DBG(""%02hhX "", data[i]);
      }
      DBG(""\\n"");
      if (DevicePathAt >= 0) {
        DBG(""%ls: %ls\\n"", Name, FileDevicePathToStr((EFI_DEVICE_PATH_PROTOCOL*)&data[DevicePathAt]));
      }
    }
  }
  if (data) {
    FreePool(data);
    return TRUE;
  }
  return FALSE;
}

VOID DbgHeader(CONST CHAR8 *str)
{
  CHAR8 strLog[50];
  INTN len;
	UINTN end = snprintf(strLog, 50, ""=== [ %s ] "", str);
  len = 50 - end;

  SetMem(&strLog[end], len , '=');
  strLog[49] = '\\0';
  DebugLog (1, ""%s\\n"", strLog);
}

// EOF
",16151,True,3018.266309938453,median
"// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2019 Intel Corporation. All Rights Reserved.

#ifdef RS2_USE_ANDROID_BACKEND

#include ""android_uvc.h""
#include ""../device_watcher.h""

#include ""../../concurrency.h""
#include ""../../types.h""
#include ""../../libuvc/uvc_types.h""
#include ""../../libuvc/utlist.h""
#include ""../../usb/usb-types.h""
#include ""../../usb/usb-device.h""
#include ""../../usbhost/messenger-usbhost.h""

#include <vector>
#include <thread>
#include <atomic>
#include <zconf.h>

#define USE_URB true
#define DEQUEUE_TIMEOUT 50
#define STREAMING_WATCHER_TIMEOUT 1000
#define STREAMING_BULK_TRANSFER_TIMEOUT 1000
#define UVC_PAYLOAD_MAX_HEADER_LENGTH 256

using namespace librealsense;

// Data structures for Backend-Frontend queue:
struct frame;
// We keep no more then 2 frames in between frontend and backend
typedef librealsense::small_heap<frame, 10> frames_archive;

struct frame {
    frame() {}

    // We don't want the frames to be overwritten at any point
    // (deallocate resets item to ""default"" that we want to avoid)
    frame(const frame &other) {}

    frame(frame &&other) {}

    frame &operator=(const frame &other) { return *this; }

    std::vector<uint8_t> pixels;
    librealsense::platform::frame_object fo;
    frames_archive *owner; // Keep pointer to owner for light-deleter
};

void cleanup_frame(frame *ptr) {
    if (ptr) ptr->owner->deallocate(ptr);
};

typedef void(*cleanup_ptr)(frame *);

// Unique_ptr is used as the simplest RAII, with static deleter
typedef std::unique_ptr<frame, cleanup_ptr> frame_ptr;
typedef single_consumer_queue<frame_ptr> frames_queue;

uvc_error_t usbhost_uvc_scan_streaming(usbhost_uvc_device *dev, usbhost_uvc_device_info_t *info,
                                       int interface_idx);

uvc_error_t usbhost_uvc_parse_vs(usbhost_uvc_device *dev, usbhost_uvc_device_info_t *info,
                                 usbhost_uvc_streaming_interface_t *stream_if,
                                 const unsigned char *block, size_t block_size);

void usbhost_uvc_free_device_info(usbhost_uvc_device_info_t *info) {
    uvc_input_terminal_t *input_term, *input_term_tmp;
    uvc_processing_unit_t *proc_unit, *proc_unit_tmp;
    uvc_extension_unit_t *ext_unit, *ext_unit_tmp;

    usbhost_uvc_streaming_interface_t *stream_if, *stream_if_tmp;
    uvc_format_desc_t *format, *format_tmp;
    uvc_frame_desc_t *frame, *frame_tmp;

    DL_FOREACH_SAFE(info->ctrl_if.input_term_descs, input_term, input_term_tmp) {
        DL_DELETE(info->ctrl_if.input_term_descs, input_term);
        free(input_term);
    }

    DL_FOREACH_SAFE(info->ctrl_if.processing_unit_descs, proc_unit, proc_unit_tmp) {
        DL_DELETE(info->ctrl_if.processing_unit_descs, proc_unit);
        free(proc_unit);
    }

    DL_FOREACH_SAFE(info->ctrl_if.extension_unit_descs, ext_unit, ext_unit_tmp) {
        DL_DELETE(info->ctrl_if.extension_unit_descs, ext_unit);
        free(ext_unit);
    }

    DL_FOREACH_SAFE(info->stream_ifs, stream_if, stream_if_tmp) {
        DL_FOREACH_SAFE(stream_if->format_descs, format, format_tmp) {
            DL_FOREACH_SAFE(format->frame_descs, frame, frame_tmp) {
                if (frame->intervals)
                    free(frame->intervals);

                DL_DELETE(format->frame_descs, frame);
                free(frame);
            }

            DL_DELETE(stream_if->format_descs, format);
            free(format);
        }

        DL_DELETE(info->stream_ifs, stream_if);
        free(stream_if);
    }

    if (info->interfaces) {
        for (int i = 0; i < MAX_USB_INTERFACES; i++) {
            if (info->interfaces->iface[i].extra != NULL) {
                //free(info->interfaces->iface[i].extra);
                info->interfaces->iface[i].extra = NULL;
            }
        }

        free(info->interfaces);
    }
}


/** @internal
* @brief Parse a VideoControl header.
* @ingroup device
*/
uvc_error_t uvc_parse_vc_header(usbhost_uvc_device *dev,
                                usbhost_uvc_device_info_t *info,
                                const unsigned char *block, size_t block_size) {
    size_t i;
    uvc_error_t scan_ret, ret = UVC_SUCCESS;


    info->ctrl_if.bcdUVC = SW_TO_SHORT(&block[3]);

    switch (info->ctrl_if.bcdUVC) {
        case 0x0100:
            info->ctrl_if.dwClockFrequency = DW_TO_INT(block + 7);
        case 0x010a:
            info->ctrl_if.dwClockFrequency = DW_TO_INT(block + 7);
        case 0x0110:
        case 0x0150:
            info->ctrl_if.dwClockFrequency = 0;
            break;
        default:
            return UVC_ERROR_NOT_SUPPORTED;
    }

    for (i = 12; i < block_size; ++i) {
        scan_ret = usbhost_uvc_scan_streaming(dev, info, block[i]);
        if (scan_ret != UVC_SUCCESS) {
            ret = scan_ret;
            break;
        }
    }

    return ret;
}

/** @internal
* @brief Parse a VideoControl input terminal.
* @ingroup device
*/
uvc_error_t uvc_parse_vc_input_terminal(usbhost_uvc_device *dev,
                                        usbhost_uvc_device_info_t *info,
                                        const unsigned char *block, size_t block_size) {
    uvc_input_terminal_t *term;
    size_t i;

    /* only supporting camera-type input terminals */
    if (SW_TO_SHORT(&block[4]) != UVC_ITT_CAMERA) {
        return UVC_SUCCESS;
    }

    term = (uvc_input_terminal_t *) calloc(1, sizeof(*term));

    term->bTerminalID = block[3];
    term->wTerminalType = (uvc_it_type) SW_TO_SHORT(&block[4]);
    term->wObjectiveFocalLengthMin = SW_TO_SHORT(&block[8]);
    term->wObjectiveFocalLengthMax = SW_TO_SHORT(&block[10]);
    term->wOcularFocalLength = SW_TO_SHORT(&block[12]);

    for (i = 14 + block[14]; i >= 15; --i)
        term->bmControls = block[i] + (term->bmControls << 8);

    DL_APPEND(info->ctrl_if.input_term_descs, term);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoControl processing unit.
* @ingroup device
*/
uvc_error_t uvc_parse_vc_processing_unit(usbhost_uvc_device *dev,
                                         usbhost_uvc_device_info_t *info,
                                         const unsigned char *block, size_t block_size) {
    uvc_processing_unit_t *unit;
    size_t i;

    unit = (uvc_processing_unit_t *) calloc(1, sizeof(*unit));
    unit->bUnitID = block[3];
    unit->bSourceID = block[4];

    for (i = 7 + block[7]; i >= 8; --i)
        unit->bmControls = block[i] + (unit->bmControls << 8);

    DL_APPEND(info->ctrl_if.processing_unit_descs, unit);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoControl selector unit.
* @ingroup device
*/
uvc_error_t uvc_parse_vc_selector_unit(usbhost_uvc_device *dev,
                                       usbhost_uvc_device_info_t *info,
                                       const unsigned char *block, size_t block_size) {
    uvc_selector_unit_t *unit;

    unit = (uvc_selector_unit_t *) calloc(1, sizeof(*unit));
    unit->bUnitID = block[3];

    DL_APPEND(info->ctrl_if.selector_unit_descs, unit);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoControl extension unit.
* @ingroup device
*/
uvc_error_t uvc_parse_vc_extension_unit(usbhost_uvc_device *dev,
                                        usbhost_uvc_device_info_t *info,
                                        const unsigned char *block, size_t block_size) {
    uvc_extension_unit_t *unit = (uvc_extension_unit_t *) calloc(1, sizeof(*unit));
    const uint8_t *start_of_controls;
    int size_of_controls, num_in_pins;
    int i;

    unit->bUnitID = block[3];
    memcpy(unit->guidExtensionCode, &block[4], 16);

    num_in_pins = block[21];
    size_of_controls = block[22 + num_in_pins];
    start_of_controls = &block[23 + num_in_pins];

    for (i = size_of_controls - 1; i >= 0; --i)
        unit->bmControls = start_of_controls[i] + (unit->bmControls << 8);

    DL_APPEND(info->ctrl_if.extension_unit_descs, unit);

    return UVC_SUCCESS;
}

/** @internal
* Process a single VideoControl descriptor block
* @ingroup device
*/
uvc_error_t uvc_parse_vc(
        usbhost_uvc_device *dev,
        usbhost_uvc_device_info_t *info,
        const unsigned char *block, size_t block_size) {
    int descriptor_subtype;
    uvc_error_t ret = UVC_SUCCESS;


    if (block[1] != 36) { // not a CS_INTERFACE descriptor??
        return UVC_SUCCESS; // UVC_ERROR_INVALID_DEVICE;
    }

    descriptor_subtype = block[2];

    switch (descriptor_subtype) {
        case UVC_VC_HEADER:
            ret = uvc_parse_vc_header(dev, info, block, block_size);
            break;
        case UVC_VC_INPUT_TERMINAL:
            ret = uvc_parse_vc_input_terminal(dev, info, block, block_size);
            break;
        case UVC_VC_OUTPUT_TERMINAL:
            break;
        case UVC_VC_SELECTOR_UNIT:
            ret = uvc_parse_vc_selector_unit(dev, info, block, block_size);
            break;
        case UVC_VC_PROCESSING_UNIT:
            ret = uvc_parse_vc_processing_unit(dev, info, block, block_size);
            break;
        case UVC_VC_EXTENSION_UNIT:
            ret = uvc_parse_vc_extension_unit(dev, info, block, block_size);
            break;
        default:
            ret = UVC_ERROR_INVALID_DEVICE;
    }

    return ret;
}

uvc_error_t usbhost_uvc_scan_control(usbhost_uvc_device *dev, usbhost_uvc_device_info_t *info,
                                     int InterfaceNumber) {
    usb_interface_descriptor *if_desc;
    uvc_error_t parse_ret, ret;
    int interface_idx;
    const unsigned char *buffer;
    size_t buffer_left, block_size;

    ret = UVC_SUCCESS;
    if_desc = NULL;

    for (interface_idx = 0; interface_idx < MAX_USB_INTERFACES; ++interface_idx) {
        if_desc = &info->interfaces->iface[interface_idx].desc;

        if (if_desc->bInterfaceClass == 14 && if_desc->bInterfaceSubClass == 1 &&
            if_desc->bInterfaceNumber == InterfaceNumber) // Video, Control
            break;
        //std::cout<<"""";

        if_desc = NULL;
    }

    if (if_desc == NULL) {
        LOG_DEBUG(""Error uvc scan control invalid device!"");
        return UVC_ERROR_INVALID_DEVICE;
    }

    info->ctrl_if.bInterfaceNumber = interface_idx;
    if (if_desc->bNumEndpoints != 0) {
        info->ctrl_if.bEndpointAddress = info->interfaces->iface[interface_idx].endpoints[0].bEndpointAddress;
    }

    buffer = info->interfaces->iface[interface_idx].extra;
    buffer_left = info->interfaces->iface[interface_idx].extraLength;

    while (buffer_left >= 3) { // parseX needs to see buf[0,2] = length,type
        block_size = buffer[0];
        //printf(""%d %x %d\\n"", buffer[0], buffer[1],buffer_left);
        parse_ret = uvc_parse_vc(dev, info, buffer, block_size);

        if (parse_ret != UVC_SUCCESS) {
            ret = parse_ret;
            break;
        }

        buffer_left -= block_size;
        buffer += block_size;
    }
    //LOG_DEBUG(""usbhost_uvc_scan_control() complete!"");
    return ret;
}

/** @internal
* Process a VideoStreaming interface
* @ingroup device
*/
uvc_error_t usbhost_uvc_scan_streaming(usbhost_uvc_device *dev,
                                       usbhost_uvc_device_info_t *info,
                                       int interface_idx) {
    const struct usbhost_uvc_interface *if_desc;
    const unsigned char *buffer;
    int buffer_left, block_size;
    uvc_error_t ret, parse_ret;
    usbhost_uvc_streaming_interface_t *stream_if;


    ret = UVC_SUCCESS;

    if_desc = &(info->interfaces->iface[interface_idx]);
    buffer = if_desc->extra;
    buffer_left = if_desc->extraLength - sizeof(usb_interface_descriptor);

    stream_if = (usbhost_uvc_streaming_interface_t *) calloc(1, sizeof(*stream_if));
    memset(stream_if, 0, sizeof(usbhost_uvc_streaming_interface_t));
    stream_if->parent = info;
    stream_if->bInterfaceNumber = if_desc->desc.bInterfaceNumber;
    DL_APPEND(info->stream_ifs, stream_if);

    while (buffer_left >= 3) {
        block_size = buffer[0];
        parse_ret = usbhost_uvc_parse_vs(dev, info, stream_if, buffer, block_size);

        if (parse_ret != UVC_SUCCESS) {
            ret = parse_ret;
            break;
        }

        buffer_left -= block_size;
        //printf(""%d %x %x %d\\n"", buffer[0], buffer[1], buffer[2], buffer_left);
        buffer += block_size;
    }

    return ret;
}

/** @internal
* @brief Parse a VideoStreaming header block.
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs_input_header(usbhost_uvc_streaming_interface_t *stream_if,
                                              const unsigned char *block,
                                              size_t block_size) {

    stream_if->bEndpointAddress = block[6] & 0x8f;
    stream_if->bTerminalLink = block[8];

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoStreaming uncompressed format block.
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs_format_uncompressed(usbhost_uvc_streaming_interface_t *stream_if,
                                                     const unsigned char *block,
                                                     size_t block_size) {

    uvc_format_desc_t *format = (uvc_format_desc_t *) calloc(1, sizeof(*format));
    memset(format, 0, sizeof(uvc_format_desc_t));
    format->parent = stream_if;
    format->bDescriptorSubtype = (uvc_vs_desc_subtype) block[2];
    format->bFormatIndex = block[3];
    //format->bmCapabilities = block[4];
    //format->bmFlags = block[5];
    memcpy(format->guidFormat, &block[5], 16);
    format->bBitsPerPixel = block[21];
    format->bDefaultFrameIndex = block[22];
    format->bAspectRatioX = block[23];
    format->bAspectRatioY = block[24];
    format->bmInterlaceFlags = block[25];
    format->bCopyProtect = block[26];

    DL_APPEND(stream_if->format_descs, format);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoStreaming frame format block.
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs_frame_format(usbhost_uvc_streaming_interface_t *stream_if,
                                              const unsigned char *block,
                                              size_t block_size) {

    uvc_format_desc_t *format = (uvc_format_desc_t *) malloc(sizeof(uvc_format_desc_t));
    memset(format, 0, sizeof(uvc_format_desc_t));
    format->parent = stream_if;
    format->bDescriptorSubtype = (uvc_vs_desc_subtype) block[2];
    format->bFormatIndex = block[3];
    format->bNumFrameDescriptors = block[4];
    memcpy(format->guidFormat, &block[5], 16);
    format->bBitsPerPixel = block[21];
    format->bDefaultFrameIndex = block[22];
    format->bAspectRatioX = block[23];
    format->bAspectRatioY = block[24];
    format->bmInterlaceFlags = block[25];
    format->bCopyProtect = block[26];
    format->bVariableSize = block[27];

    DL_APPEND(stream_if->format_descs, format);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoStreaming MJPEG format block.
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs_format_mjpeg(usbhost_uvc_streaming_interface_t *stream_if,
                                              const unsigned char *block,
                                              size_t block_size) {

    uvc_format_desc_t *format = (uvc_format_desc_t *) calloc(1, sizeof(*format));

    format->parent = stream_if;
    format->bDescriptorSubtype = (uvc_vs_desc_subtype) block[2];
    format->bFormatIndex = block[3];
    memcpy(format->fourccFormat, ""MJPG"", 4);
    format->bmFlags = block[5];
    format->bBitsPerPixel = 0;
    format->bDefaultFrameIndex = block[6];
    format->bAspectRatioX = block[7];
    format->bAspectRatioY = block[8];
    format->bmInterlaceFlags = block[9];
    format->bCopyProtect = block[10];

    DL_APPEND(stream_if->format_descs, format);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoStreaming uncompressed frame block.
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs_frame_frame(usbhost_uvc_streaming_interface_t *stream_if,
                                             const unsigned char *block,
                                             size_t block_size) {
    uvc_format_desc_t *format;
    uvc_frame_desc_t *frame;

    const unsigned char *p;
    int i;

    format = stream_if->format_descs->prev;
    frame = (uvc_frame_desc_t *) malloc(sizeof(uvc_frame_desc_t));
    memset(frame, 0, sizeof(uvc_frame_desc_t));
    frame->parent = format;

    frame->bDescriptorSubtype = (uvc_vs_desc_subtype) block[2];
    frame->bFrameIndex = block[3];
    frame->bmCapabilities = block[4];
    frame->wWidth = block[5] + (block[6] << 8);
    frame->wHeight = block[7] + (block[8] << 8);
    frame->dwMinBitRate = DW_TO_INT(&block[9]);
    frame->dwMaxBitRate = DW_TO_INT(&block[13]);
    frame->dwDefaultFrameInterval = DW_TO_INT(&block[17]);
    frame->bFrameIntervalType = block[21];
    frame->dwBytesPerLine = DW_TO_INT(&block[22]);

    if (block[21] == 0) {
        frame->dwMinFrameInterval = DW_TO_INT(&block[26]);
        frame->dwMaxFrameInterval = DW_TO_INT(&block[30]);
        frame->dwFrameIntervalStep = DW_TO_INT(&block[34]);
    } else {
        frame->intervals = (uint32_t *) malloc((block[21] + 1) * sizeof(uint32_t));
        p = &block[26];

        for (i = 0; i < block[21]; ++i) {
            frame->intervals[i] = DW_TO_INT(p);
            p += 4;
        }
        frame->intervals[block[21]] = 0;
    }

    DL_APPEND(format->frame_descs, frame);

    return UVC_SUCCESS;
}

/** @internal
* @brief Parse a VideoStreaming uncompressed frame block.
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs_frame_uncompressed(usbhost_uvc_streaming_interface_t *stream_if,
                                                    const unsigned char *block,
                                                    size_t block_size) {
    uvc_format_desc_t *format;
    uvc_frame_desc_t *frame;

    const unsigned char *p;
    int i;

    format = stream_if->format_descs->prev;
    frame = (uvc_frame_desc_t *) calloc(1, sizeof(*frame));
    memset(frame, 0, sizeof(uvc_frame_desc_t));
    frame->parent = format;

    frame->bDescriptorSubtype = (uvc_vs_desc_subtype) block[2];
    frame->bFrameIndex = block[3];
    frame->bmCapabilities = block[4];
    frame->wWidth = block[5] + (block[6] << 8);
    frame->wHeight = block[7] + (block[8] << 8);
    frame->dwMinBitRate = DW_TO_INT(&block[9]);
    frame->dwMaxBitRate = DW_TO_INT(&block[13]);
    frame->dwMaxVideoFrameBufferSize = DW_TO_INT(&block[17]);
    frame->dwDefaultFrameInterval = DW_TO_INT(&block[21]);
    frame->bFrameIntervalType = block[25];

    if (block[25] == 0) {
        frame->dwMinFrameInterval = DW_TO_INT(&block[26]);
        frame->dwMaxFrameInterval = DW_TO_INT(&block[30]);
        frame->dwFrameIntervalStep = DW_TO_INT(&block[34]);
    } else {
        frame->intervals = (uint32_t *) calloc(block[25] + 1, sizeof(frame->intervals[0]));
        p = &block[26];

        for (i = 0; i < block[25]; ++i) {
            frame->intervals[i] = DW_TO_INT(p);
            p += 4;
        }
        frame->intervals[block[25]] = 0;
    }

    DL_APPEND(format->frame_descs, frame);

    return UVC_SUCCESS;
}

/** @internal
* Process a single VideoStreaming descriptor block
* @ingroup device
*/
uvc_error_t usbhost_uvc_parse_vs(
        usbhost_uvc_device *dev,
        usbhost_uvc_device_info_t *info,
        usbhost_uvc_streaming_interface_t *stream_if,
        const unsigned char *block, size_t block_size) {
    uvc_error_t ret;
    int descriptor_subtype;

    ret = UVC_SUCCESS;
    descriptor_subtype = block[2];

    switch (descriptor_subtype) {
        case UVC_VS_INPUT_HEADER:
            ret = usbhost_uvc_parse_vs_input_header(stream_if, block, block_size);
            break;
        case UVC_VS_FORMAT_UNCOMPRESSED:
            ret = usbhost_uvc_parse_vs_format_uncompressed(stream_if, block, block_size);
            break;
        case UVC_VS_FORMAT_MJPEG:
            ret = usbhost_uvc_parse_vs_format_mjpeg(stream_if, block, block_size);
            break;
        case UVC_VS_FRAME_UNCOMPRESSED:
        case UVC_VS_FRAME_MJPEG:
            ret = usbhost_uvc_parse_vs_frame_uncompressed(stream_if, block, block_size);
            break;
        case UVC_VS_FORMAT_FRAME_BASED:
            ret = usbhost_uvc_parse_vs_frame_format(stream_if, block, block_size);
            break;
        case UVC_VS_FRAME_FRAME_BASED:
            ret = usbhost_uvc_parse_vs_frame_frame(stream_if, block, block_size);
            break;
        case UVC_VS_COLORFORMAT:
            break;

        default:
            /** @todo handle JPEG and maybe still frames or even DV... */
            /*fprintf(stderr, ""unsupported descriptor subtype: %d\\n"",
            descriptor_subtype);*/
            break;
    }

    return ret;
}

uvc_error_t update_stream_if_handle(usbhost_uvc_device *devh, int interface_idx) {
    usbhost_uvc_streaming_interface_t *stream_if;

    DL_FOREACH(devh->deviceData.stream_ifs, stream_if) {
        if (stream_if->bInterfaceNumber == interface_idx)
            if (!stream_if->interface && interface_idx < MAX_USB_INTERFACES) {
                // usbhost_GetAssociatedInterface returns the associated interface (Video stream interface which is associated to Video control interface)
                // A value of 0 indicates the first associated interface (Video Stream 1), a value of 1 indicates the second associated interface (video stream 2)
                // WinUsbInterfaceNumber is the actual interface number taken from the USB config descriptor
                // A value of 0 indicates the first interface (Video Control Interface), A value of 1 indicates the first associated interface (Video Stream 1)
                // For this reason, when calling to usbhost_GetAssociatedInterface, we must decrease 1 to receive the associated interface
                auto intfs = devh->device->get_interfaces();
                auto it = std::find_if(intfs.begin(), intfs.end(),
                                       [&](const librealsense::platform::rs_usb_interface& i) { return i->get_number() == interface_idx; });
                if (it != intfs.end())
                    stream_if->interface = *it;
            }
    }
    return UVC_SUCCESS;
}

/* Return only Video stream interfaces */
static usbhost_uvc_streaming_interface_t* usbhost_uvc_get_stream_if(usbhost_uvc_device *devh, int interface_idx)
{
    usbhost_uvc_streaming_interface_t *stream_if;

    DL_FOREACH(devh->deviceData.stream_ifs, stream_if)
    {
        if (stream_if->bInterfaceNumber == interface_idx)
        {
            return stream_if;
        }
    }

    return NULL;
}

/** Return all device formats available
* @ingroup streaming
*
* @param[in] devh Device Handle
* @param[out] formats returned
*/

#define SWAP_UINT32(x) (((x) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | ((x) << 24))

uvc_error_t usbhost_get_available_formats(
        usbhost_uvc_device *devh,
        int interface_idx,
        uvc_format_t **formats) {

    usbhost_uvc_streaming_interface_t *stream_if = NULL;
    uvc_format_t *prev_format = NULL;
    uvc_format_desc_t *format;

    stream_if = usbhost_uvc_get_stream_if(devh, interface_idx);
    if (stream_if == NULL) {
        return UVC_ERROR_INVALID_PARAM;
    }

    DL_FOREACH(stream_if->format_descs, format) {
        uint32_t *interval_ptr;
        uvc_frame_desc_t *frame_desc;

        DL_FOREACH(format->frame_descs, frame_desc) {
            for (interval_ptr = frame_desc->intervals;
                 *interval_ptr;
                 ++interval_ptr) {
                uvc_format_t *cur_format = (uvc_format_t *) malloc(sizeof(uvc_format_t));
                cur_format->height = frame_desc->wHeight;
                cur_format->width = frame_desc->wWidth;
                cur_format->fourcc = SWAP_UINT32(*(const uint32_t *) format->guidFormat);

                cur_format->fps = 10000000 / *interval_ptr;
                cur_format->next = NULL;

                if (prev_format != NULL) {
                    prev_format->next = cur_format;
                } else {
                    *formats = cur_format;
                }

                prev_format = cur_format;
            }
        }
    }
    return UVC_SUCCESS;
}

// Return linked list of uvc_format_t of all available formats inside winusb device
uvc_error_t usbhost_get_available_formats_all(usbhost_uvc_device *devh, uvc_format_t **formats) {

    usbhost_uvc_streaming_interface_t *stream_if = NULL;
    uvc_format_t *prev_format = NULL;
    uvc_format_desc_t *format;

    DL_FOREACH(devh->deviceData.stream_ifs, stream_if) {
        DL_FOREACH(stream_if->format_descs, format) {
            uint32_t *interval_ptr;
            uvc_frame_desc_t *frame_desc;

            DL_FOREACH(format->frame_descs, frame_desc) {
                for (interval_ptr = frame_desc->intervals;
                     *interval_ptr;
                     ++interval_ptr) {
                    uvc_format_t *cur_format = (uvc_format_t *) malloc(sizeof(uvc_format_t));
                    cur_format->height = frame_desc->wHeight;
                    cur_format->width = frame_desc->wWidth;
                    auto temp = SWAP_UINT32(*(const uint32_t *) format->guidFormat);
                    cur_format->fourcc = fourcc_map.count(temp) ? fourcc_map.at(temp) : temp;
                    cur_format->interfaceNumber = stream_if->bInterfaceNumber;

                    cur_format->fps = 10000000 / *interval_ptr;
                    cur_format->next = NULL;

                    if (prev_format != NULL) {
                        prev_format->next = cur_format;
                    } else {
                        *formats = cur_format;
                    }

                    prev_format = cur_format;
                }
            }
        }
    }
    return UVC_SUCCESS;
}

uvc_error_t usbhost_free_formats(uvc_format_t *formats) {
    uvc_format_t *cur_format = formats;
    while (cur_format != NULL) {
        uvc_format_t *format = cur_format;
        cur_format = cur_format->next;
        free(format);
    }

    return UVC_SUCCESS;
}

/** @internal
* @brief Find the descriptor for a specific frame configuration
* @param stream_if Stream interface
* @param format_id Index of format class descriptor
* @param frame_id Index of frame descriptor
*/
static uvc_frame_desc_t *
usbhost_uvc_find_frame_desc_stream_if(usbhost_uvc_streaming_interface_t *stream_if,
                                      uint16_t format_id, uint16_t frame_id) {

    uvc_format_desc_t *format = NULL;
    uvc_frame_desc_t *frame = NULL;

    DL_FOREACH(stream_if->format_descs, format) {
        if (format->bFormatIndex == format_id) {
            DL_FOREACH(format->frame_descs, frame) {
                if (frame->bFrameIndex == frame_id)
                    return frame;
            }
        }
    }

    return NULL;
}

uvc_frame_desc_t *usbhost_uvc_find_frame_desc_stream(usbhost_uvc_stream_handle_t *strmh,
                                                     uint16_t format_id, uint16_t frame_id) {
    return usbhost_uvc_find_frame_desc_stream_if(strmh->stream_if, format_id, frame_id);
}

void usbhost_uvc_process_bulk_payload(frame_ptr fp, size_t payload_len, frames_queue& queue) {

    /* ignore empty payload transfers */
    if (!fp || payload_len < 2)
        return;

    uint8_t header_len = fp->pixels[0];
    uint8_t header_info = fp->pixels[1];

    size_t data_len = payload_len - header_len;

    if (header_info & 0x40)
    {
        LOG_ERROR(""bad packet: error bit set"");
        return;
    }
    if (header_len > payload_len)
    {
        LOG_ERROR(""bogus packet: actual_len="" << payload_len << "", header_len="" << header_len);
        return;
    }


    LOG_DEBUG(""Passing packet to user CB with size "" << (data_len + header_len));
    librealsense::platform::frame_object fo{ data_len, header_len,
                                             fp->pixels.data() + header_len , fp->pixels.data() };
    fp->fo = fo;

    queue.enqueue(std::move(fp));
}

void stream_thread_bulk(usbhost_uvc_stream_context *strctx) {
    auto inf = strctx->stream->stream_if->interface;
    auto dev = strctx->stream->devh->device;
    auto messenger = dev->open();

    auto read_ep = inf->first_endpoint(librealsense::platform::RS2_USB_ENDPOINT_DIRECTION_READ);
    uint32_t reset_ep_timeout = 100;
    messenger->reset_endpoint(read_ep, reset_ep_timeout);

    frames_archive archive;
    std::atomic_bool keep_sending_callbacks(true);
    frames_queue queue;

    uint32_t read_buff_length = UVC_PAYLOAD_MAX_HEADER_LENGTH + strctx->stream->cur_ctrl.dwMaxVideoFrameSize;
    LOG_INFO(""endpoint "" << (int)read_ep->get_address() << "" read buffer size: "" << read_buff_length);

    // Get all pointers from archive and initialize their content
    std::vector<frame *> frames;
    for (auto i = 0; i < frames_archive::CAPACITY; i++) {
        auto ptr = archive.allocate();
        ptr->pixels.resize(read_buff_length, 0);
        ptr->owner = &archive;
        frames.push_back(ptr);
    }

    for (auto ptr : frames) {
        archive.deallocate(ptr);
    }

    std::thread t([&]() {
        while (keep_sending_callbacks) {
            frame_ptr fp(nullptr, [](frame *) {});
            if (queue.dequeue(&fp, DEQUEUE_TIMEOUT)) {
                strctx->stream->user_cb(&fp->fo, strctx->stream->user_ptr);
            }
        }
    });
    LOG_DEBUG(""Transfer thread started for endpoint address: "" << strctx->endpoint);
    bool fatal_error = false;
    do {
        frame_ptr fp = frame_ptr(archive.allocate(), &cleanup_frame);
        if(!fp)
            continue;
        auto i = strctx->stream->stream_if->interface;
        uint32_t transferred = 0;
        auto sts = messenger->bulk_transfer(read_ep, fp->pixels.data(), read_buff_length, transferred, STREAMING_BULK_TRANSFER_TIMEOUT);
//        LOG_INFO(""endpoint: "" << (int)read_ep->get_address() << "", sts: "" << (int)sts << "", expected: "" << (int)read_buff_length << "", actual: "" << (int)transferred);
        switch(sts)
        {
            case librealsense::platform::RS2_USB_STATUS_NO_MEM:
                LOG_ERROR(""USB transfer failed, the max read buffer size is smaller than the current resolution requires, try to configure lower resolution"");
            case librealsense::platform::RS2_USB_STATUS_OVERFLOW:
            case librealsense::platform::RS2_USB_STATUS_NO_DEVICE:
                fatal_error = true;
                break;
            case librealsense::platform::RS2_USB_STATUS_PIPE:
            case librealsense::platform::RS2_USB_STATUS_INVALID_PARAM:
                messenger->reset_endpoint(read_ep, reset_ep_timeout);
                break;
            case librealsense::platform::RS2_USB_STATUS_SUCCESS:
                //we support only bulk transfer mode, so we expect the frame to arrive in a single payload
                if(transferred > 0)
                {
                    if(transferred == (fp->pixels[0] + strctx->stream->cur_ctrl.dwMaxVideoFrameSize))
                        usbhost_uvc_process_bulk_payload(std::move(fp), transferred, queue);
                }
                break;
            default:
                break;
        }
    } while (!fatal_error && strctx->stream->running);

    int ep = strctx->endpoint;
    messenger->reset_endpoint(read_ep, reset_ep_timeout);
    free(strctx);

    queue.clear();
    archive.stop_allocation();
    archive.wait_until_empty();
    keep_sending_callbacks = false;

    LOG_DEBUG(""start join stream_thread"");
    t.join();

    LOG_DEBUG(""Transfer thread stopped for endpoint address: "" << ep);
};

void stream_thread_urb(usbhost_uvc_stream_context *strctx) {
    auto inf = strctx->stream->stream_if->interface;
    auto dev = strctx->stream->devh->device;
    auto messenger = std::static_pointer_cast<platform::usb_messenger_usbhost>(dev->open());

    auto read_ep = std::static_pointer_cast<platform::usb_endpoint_usbhost>
            (inf->first_endpoint(platform::RS2_USB_ENDPOINT_DIRECTION_READ));

    uint32_t reset_ep_timeout = 100;
    messenger->reset_endpoint(read_ep, reset_ep_timeout);

    frames_archive archive;
    std::atomic_bool keep_sending_callbacks(true);
    frames_queue queue;

    uint32_t read_buff_length = UVC_PAYLOAD_MAX_HEADER_LENGTH + strctx->stream->cur_ctrl.dwMaxVideoFrameSize;
    LOG_INFO(""endpoint "" << (int)read_ep->get_address() << "" read buffer size: "" << read_buff_length);

    // Get all pointers from archive and initialize their content
    std::vector<frame *> frames;
    for (auto i = 0; i < frames_archive::CAPACITY; i++) {
        auto ptr = archive.allocate();
        ptr->pixels.resize(read_buff_length, 0);
        ptr->owner = &archive;
        frames.push_back(ptr);
    }

    for (auto ptr : frames) {
        archive.deallocate(ptr);
    }

    std::thread t([&]() {
        while (keep_sending_callbacks) {
            frame_ptr fp(nullptr, [](frame *) {});
            if (queue.dequeue(&fp, DEQUEUE_TIMEOUT)) {
                strctx->stream->user_cb(&fp->fo, strctx->stream->user_ptr);
            }
        }
    });

    frame_ptr fp = frame_ptr(archive.allocate(), &cleanup_frame);

    auto desc = read_ep->get_descriptor();
    std::shared_ptr<usb_request> request = std::shared_ptr<usb_request>(usb_request_new(dev->get_handle(),
                                                                                        &desc), [](usb_request* req) {usb_request_free(req);});
    if(!request)
    {
        LOG_ERROR(""invalid USB request"");
        return;
    }

    bool fatal_error = false;
    uint32_t frame_count = 0;
    int active_request_count = 0;
    uint32_t zero_response = 0;
    auto callback = std::make_shared<platform::usb_request_callback>([&](usb_request* r)
    {
     if(r)
     {
         active_request_count--;
         if(r->actual_length == 0){
             LOG_WARNING(""read_ep: "" << r->endpoint << "", zero response"");
             zero_response++;
             if(zero_response > 10)
             {
                 messenger->reset_endpoint(read_ep, reset_ep_timeout);
                 zero_response = 0;
             }
         }
         if(r->actual_length >= strctx->stream->cur_ctrl.dwMaxVideoFrameSize){
             zero_response = 0;
             frame_count++;
             usbhost_uvc_process_bulk_payload(std::move(fp), r->actual_length, queue);
         }
     }

     if(!strctx->stream->running){
         return;
     }

     fp = frame_ptr(archive.allocate(), &cleanup_frame);
     if(!fp)
         return;
     request->buffer = fp->pixels.data();
     request->buffer_length = fp->pixels.size();

     auto sts =  messenger->submit_request(request);
     switch(sts)
     {
         case platform::RS2_USB_STATUS_SUCCESS:
             active_request_count++;
             return;
         case platform::RS2_USB_STATUS_OVERFLOW:
         case platform::RS2_USB_STATUS_NO_DEVICE:
         case platform::RS2_USB_STATUS_NO_MEM:
             fatal_error = true;
             return;
         default:
             messenger->reset_endpoint(read_ep, reset_ep_timeout);
             break;
     }
    });

    request->client_data = callback.get();

    while(!fatal_error && strctx->stream->running)
    {
        if(frame_count == 0){
            if(active_request_count > 0)
            {
                messenger->cancel_request(request);
                active_request_count--;
            }
            callback->callback(nullptr);
        }
        frame_count = 0;
        std::this_thread::sleep_for(std::chrono::milliseconds(STREAMING_WATCHER_TIMEOUT));
    }

    if(active_request_count > 0)
    {
        messenger->cancel_request(request);
        active_request_count--;
    }
    LOG_INFO(""read endpoint: "" << (int)read_ep->get_address() <<"", active requests count: "" << active_request_count);

    callback->cancel();
    messenger->reset_endpoint(read_ep, reset_ep_timeout);
    free(strctx);
    queue.clear();
    archive.stop_allocation();
    fp.reset();
    archive.wait_until_empty();
    keep_sending_callbacks = false;

    LOG_INFO(""start join stream_thread"");
    t.join();
    LOG_INFO(""Transfer thread stopped for endpoint address: "" << (int)read_ep->get_address());
};

void stream_thread(usbhost_uvc_stream_context *strctx){
    if(USE_URB)
        stream_thread_urb(strctx);
    else
        stream_thread_bulk(strctx);
}
uvc_error_t usbhost_uvc_stream_start(
        usbhost_uvc_stream_handle_t *strmh,
        usbhost_uvc_frame_callback_t *cb,
        void *user_ptr,
        uint8_t flags
) {
    /* USB interface we'll be using */
    usbhost_uvc_interface *iface;
    int interface_id;
    uvc_frame_desc_t *frame_desc;
    uvc_format_desc_t *format_desc;
    uvc_stream_ctrl_t *ctrl;
    uvc_error_t ret;
    /* Total amount of data per transfer */

    ctrl = &strmh->cur_ctrl;

    if (strmh->running) {
        return UVC_ERROR_BUSY;
    }

    strmh->running = 1;
    strmh->seq = 1;
    strmh->fid = 0;
    strmh->pts = 0;
    strmh->last_scr = 0;

    frame_desc = usbhost_uvc_find_frame_desc_stream(strmh, ctrl->bFormatIndex, ctrl->bFrameIndex);
    if (!frame_desc) {
        ret = UVC_ERROR_INVALID_PARAM;
        strmh->running = 0;
        return ret;
    }
    format_desc = frame_desc->parent;

    // Get the interface that provides the chosen format and frame configuration
    interface_id = strmh->stream_if->bInterfaceNumber;
    iface = &strmh->devh->deviceData.interfaces->iface[interface_id];

    usbhost_uvc_stream_context *streamctx = new usbhost_uvc_stream_context;

    streamctx->stream = strmh;
    streamctx->endpoint = format_desc->parent->bEndpointAddress;
    streamctx->iface = iface;
    streamctx->maxPayloadTransferSize = strmh->cur_ctrl.dwMaxPayloadTransferSize;
    streamctx->maxVideoBufferSize = strmh->cur_ctrl.dwMaxVideoFrameSize;
    strmh->user_ptr = user_ptr;
    strmh->cb_thread = std::thread(stream_thread, streamctx);
    strmh->user_cb = cb;

    return UVC_SUCCESS;

}

uvc_error_t usbhost_uvc_stream_stop(usbhost_uvc_stream_handle_t *strmh) {
    if (!strmh->running)
        return UVC_ERROR_INVALID_PARAM;

    strmh->running = false;
    LOG_DEBUG(""start join cb_thread"");
    strmh->cb_thread.join();
    LOG_DEBUG(""cb_thread joined"");

    return UVC_SUCCESS;
}

void usbhost_uvc_stream_close(usbhost_uvc_stream_handle_t *strmh) {
    if (strmh->running) {
        usbhost_uvc_stream_stop(strmh);
    }

    free(strmh->outbuf);
    free(strmh->holdbuf);

    DL_DELETE(strmh->devh->streams, strmh);

    free(strmh->user_ptr);
    free(strmh);
}

uvc_error_t usbhost_uvc_stream_open_ctrl(usbhost_uvc_device *devh, usbhost_uvc_stream_handle_t **strmhp,
                                         uvc_stream_ctrl_t *ctrl);

uvc_error_t usbhost_start_streaming(usbhost_uvc_device *devh, uvc_stream_ctrl_t *ctrl,
                                    usbhost_uvc_frame_callback_t *cb, void *user_ptr,
                                    uint8_t flags) {
    uvc_error_t ret;
    usbhost_uvc_stream_handle_t *strmh;

    ret = usbhost_uvc_stream_open_ctrl(devh, &strmh, ctrl);
    if (ret != UVC_SUCCESS) {
        return ret;
    }

    ret = usbhost_uvc_stream_start(strmh, cb, user_ptr, flags);
    if (ret != UVC_SUCCESS) {
        usbhost_uvc_stream_close(strmh);
        return ret;
    }

    return UVC_SUCCESS;
}

void usbhost_stop_streaming(usbhost_uvc_device *devh) {
    usbhost_uvc_stream_handle_t *strmh, *strmh_tmp;

    DL_FOREACH_SAFE(devh->streams, strmh, strmh_tmp) {
        usbhost_uvc_stream_close(strmh);
    }
}


/** @internal
* @brief Find the descriptor for a specific frame configuration
* @param devh UVC device
* @param format_id Index of format class descriptor
* @param frame_id Index of frame descriptor
*/
uvc_frame_desc_t *usbhost_uvc_find_frame_desc(usbhost_uvc_device *devh,
                                              uint16_t format_id, uint16_t frame_id) {

    usbhost_uvc_streaming_interface_t *stream_if;
    uvc_frame_desc_t *frame;

    DL_FOREACH(devh->deviceData.stream_ifs, stream_if) {
        frame = usbhost_uvc_find_frame_desc_stream_if(stream_if, format_id, frame_id);
        if (frame)
            return frame;
    }

    return NULL;
}

uvc_error_t
usbhost_uvc_query_stream_ctrl(usbhost_uvc_device *devh, uvc_stream_ctrl_t *ctrl, uint8_t probe,
                              int req) {
    uint8_t buf[48];
    size_t len;
    int err;

    memset(buf, 0, sizeof(buf));

    switch (devh->deviceData.ctrl_if.bcdUVC) {
        case 0x0110:
            len = 34;
            break;
        case 0x0150:
            len = 48;
            break;
        default:
            len = 26;
            break;
    }
    /* prepare for a SET transfer */
    if (req == UVC_SET_CUR) {
        SHORT_TO_SW(ctrl->bmHint, buf);
        buf[2] = ctrl->bFormatIndex;
        buf[3] = ctrl->bFrameIndex;
        INT_TO_DW(ctrl->dwFrameInterval, buf + 4);
        SHORT_TO_SW(ctrl->wKeyFrameRate, buf + 8);
        SHORT_TO_SW(ctrl->wPFrameRate, buf + 10);
        SHORT_TO_SW(ctrl->wCompQuality, buf + 12);
        SHORT_TO_SW(ctrl->wCompWindowSize, buf + 14);
        SHORT_TO_SW(ctrl->wDelay, buf + 16);
        INT_TO_DW(ctrl->dwMaxVideoFrameSize, buf + 18);
        INT_TO_DW(ctrl->dwMaxPayloadTransferSize, buf + 22);
        INT_TO_DW(0, buf + 18);
        INT_TO_DW(0, buf + 22);

        if (len >= 34) {
            INT_TO_DW(ctrl->dwClockFrequency, buf + 26);
            buf[30] = ctrl->bmFramingInfo;
            buf[31] = ctrl->bPreferredVersion;
            buf[32] = ctrl->bMinVersion;
            buf[33] = ctrl->bMaxVersion;
            /** @todo support UVC 1.1 */
        }

        if (len == 48) {
            buf[34] = ctrl->bUsage;
            buf[35] = ctrl->bBitDepthLuma;
            buf[36] = ctrl->bmSettings;
            buf[37] = ctrl->bMaxNumberOfRefFramesPlus1;
            SHORT_TO_SW(ctrl->bmRateControlModes, buf + 38);
            QUAD_TO_QW(ctrl->bmLayoutPerStream, buf + 40);
        }
    }
    int retries = 0;
    do {
        //auto str_if = usbhost_uvc_get_stream_if(devh, ctrl->bInterfaceNumber);
        /* do the transfer */
        err = usb_device_control_transfer(
                devh->device->get_handle(),
                req == UVC_SET_CUR ? UVC_REQ_TYPE_SET : UVC_REQ_TYPE_GET,
                req,
                probe ? (UVC_VS_PROBE_CONTROL << 8) : (UVC_VS_COMMIT_CONTROL << 8),
                ctrl->bInterfaceNumber, // When requestType is directed to an interface, WinUsb driver automatically passes the interface number in the low byte of index
                buf, len, 0);
    } while (err < 0 && retries++ < 5);

    if (err <= 0) {
        LOG_ERROR(""Probe-commit control transfer failed with errno: "" << errno << "" - "" << strerror(errno));
        return (uvc_error_t) err;
    }

    /* now decode following a GET transfer */
    if (req != UVC_SET_CUR) {
        ctrl->bmHint = SW_TO_SHORT(buf);
        ctrl->bFormatIndex = buf[2];
        ctrl->bFrameIndex = buf[3];
        ctrl->dwFrameInterval = DW_TO_INT(buf + 4);
        ctrl->wKeyFrameRate = SW_TO_SHORT(buf + 8);
        ctrl->wPFrameRate = SW_TO_SHORT(buf + 10);
        ctrl->wCompQuality = SW_TO_SHORT(buf + 12);
        ctrl->wCompWindowSize = SW_TO_SHORT(buf + 14);
        ctrl->wDelay = SW_TO_SHORT(buf + 16);
        ctrl->dwMaxVideoFrameSize = DW_TO_INT(buf + 18);
        ctrl->dwMaxPayloadTransferSize = DW_TO_INT(buf + 22);

        if (len >= 34) {
            ctrl->dwClockFrequency = DW_TO_INT(buf + 26);
            ctrl->bmFramingInfo = buf[30];
            ctrl->bPreferredVersion = buf[31];
            ctrl->bMinVersion = buf[32];
            ctrl->bMaxVersion = buf[33];
            /** @todo support UVC 1.1 */
        }

        if (len == 48) {
            ctrl->bUsage = buf[34];
            ctrl->bBitDepthLuma = buf[35];
            ctrl->bmSettings = buf[36];
            ctrl->bMaxNumberOfRefFramesPlus1 = buf[37];
            ctrl->bmRateControlModes = DW_TO_INT(buf + 38);
            ctrl->bmLayoutPerStream = QW_TO_QUAD(buf + 40);
        }
        //         else
        //             ctrl->dwClockFrequency = devh->info->ctrl_if.dwClockFrequency;

        /* fix up block for cameras that fail to set dwMax* */
        if (ctrl->dwMaxVideoFrameSize == 0) {
            uvc_frame_desc_t *frame = usbhost_uvc_find_frame_desc(devh, ctrl->bFormatIndex,
                                                                  ctrl->bFrameIndex);

            if (frame) {
                ctrl->dwMaxVideoFrameSize = frame->dwMaxVideoFrameBufferSize;
            }
        }
    }
    return UVC_SUCCESS;
}

/** @brief Reconfigure stream with a new stream format.
* @ingroup streaming
*
* This may be executed whether or not the stream is running.
*
* @param[in] strmh Stream handle
* @param[in] ctrl Control block, processed using {usbhost_uvc_probe_stream_ctrl} or
*             {uvc_get_stream_ctrl_format_size}
*/
uvc_error_t usbhost_uvc_stream_ctrl(usbhost_uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl) {
    uvc_error_t ret = UVC_SUCCESS;

    if (strmh->stream_if->bInterfaceNumber != ctrl->bInterfaceNumber) {
        return UVC_ERROR_INVALID_PARAM;
    }

    /* @todo Allow the stream to be modified without restarting the stream */
    if (strmh->running) {
        return UVC_ERROR_BUSY;
    }

    // Set streaming control block
    ret = usbhost_uvc_query_stream_ctrl(strmh->devh, ctrl, 0, UVC_SET_CUR);
    if (ret != UVC_SUCCESS) {
        return ret;
    }

    strmh->cur_ctrl = *ctrl;
    return UVC_SUCCESS;
}

static usbhost_uvc_stream_handle_t *
usbhost_uvc_get_stream_by_interface(usbhost_uvc_device *devh, int interface_idx) {
    usbhost_uvc_stream_handle_t *strmh;

    DL_FOREACH(devh->streams, strmh) {
        if (strmh->stream_if->bInterfaceNumber == interface_idx)
            return strmh;
    }

    return NULL;
}

uvc_error_t
usbhost_uvc_stream_open_ctrl(usbhost_uvc_device *devh, usbhost_uvc_stream_handle_t **strmhp,
                             uvc_stream_ctrl_t *ctrl) {
    /* Chosen frame and format descriptors */
    usbhost_uvc_stream_handle_t *strmh = NULL;
    usbhost_uvc_streaming_interface_t *stream_if;
    uvc_error_t ret;

    if (usbhost_uvc_get_stream_by_interface(devh, ctrl->bInterfaceNumber) != NULL) {
        ret = UVC_ERROR_BUSY; /* Stream is already opened */
        goto fail;
    }

    stream_if = usbhost_uvc_get_stream_if(devh, ctrl->bInterfaceNumber);
    if (!stream_if) {
        ret = UVC_ERROR_INVALID_PARAM;
        goto fail;
    }

    strmh = (usbhost_uvc_stream_handle_t *) calloc(1, sizeof(*strmh));
    if (!strmh) {
        ret = UVC_ERROR_NO_MEM;
        goto fail;
    }
    memset(strmh, 0, sizeof(usbhost_uvc_stream_handle_t));
    strmh->devh = devh;
    strmh->stream_if = stream_if;
    //strmh->frame.library_owns_data = 1;


    //TODO: Fix this
    ret = usbhost_uvc_stream_ctrl(strmh, ctrl);
    if (ret != UVC_SUCCESS)
        goto fail;

    // Set up the streaming status and data space
    strmh->running = 0;
    /** @todo take only what we need */
    strmh->outbuf = (uint8_t *) malloc(LIBUVC_XFER_BUF_SIZE);
    strmh->holdbuf = (uint8_t *) malloc(LIBUVC_XFER_BUF_SIZE);

    /*pthread_mutex_init(&strmh->cb_mutex, NULL);
    pthread_cond_init(&strmh->cb_cond, NULL);*/

    DL_APPEND(devh->streams, strmh);

    *strmhp = strmh;

    return UVC_SUCCESS;

    fail:
    if (strmh)
        free(strmh);
    return ret;
}

// Probe (Set and Get) streaming control block
uvc_error_t usbhost_uvc_probe_stream_ctrl(usbhost_uvc_device *devh, uvc_stream_ctrl_t *ctrl) {
    uvc_error_t ret = UVC_SUCCESS;

    // Sending probe SET request - UVC_SET_CUR request in a probe/commit structure containing desired values for VS Format index, VS Frame index, and VS Frame Interval
    // UVC device will check the VS Format index, VS Frame index, and Frame interval properties to verify if possible and update the probe/commit structure if feasible
    ret = usbhost_uvc_query_stream_ctrl(devh, ctrl, 1, UVC_SET_CUR);
    if (ret != UVC_SUCCESS) {
        return ret;
    }

    // Sending probe GET request - UVC_GET_CUR request to read the updated values from UVC device
    ret = usbhost_uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_CUR);
    if (ret != UVC_SUCCESS) {
        return ret;
    }

    /** @todo make sure that worked */
    return UVC_SUCCESS;
}

/** Get a negotiated streaming control block for some common parameters for specific interface
* @ingroup streaming
*
* @param[in] devh Device handle
* @param[in,out] ctrl Control block
* @param[in] format_class Type of streaming format
* @param[in] width Desired frame width
* @param[in] height Desired frame height
* @param[in] fps Frame rate, frames per second
*/
uvc_error_t usbhost_get_stream_ctrl_format_size(
        usbhost_uvc_device *devh,
        uvc_stream_ctrl_t *ctrl,
        uint32_t fourcc,
        int width, int height,
        int fps,
        int interface_idx
) {
    usbhost_uvc_streaming_interface_t *stream_if;
    uvc_format_desc_t *format;
    uvc_error_t ret = UVC_SUCCESS;

    stream_if = usbhost_uvc_get_stream_if(devh, interface_idx);
    if (stream_if == NULL) {
        return UVC_ERROR_INVALID_PARAM;
    }

    DL_FOREACH(stream_if->format_descs, format) {
        uvc_frame_desc_t *frame;
        //TODO
        auto val = SWAP_UINT32(*(const uint32_t *) format->guidFormat);
        if(fourcc_map.count(val))
            val = fourcc_map.at(val);

        if (fourcc != val)
            continue;

        DL_FOREACH(format->frame_descs, frame) {
            if (frame->wWidth != width || frame->wHeight != height)
                continue;

            uint32_t *interval;
            if (frame->intervals) {
                for (interval = frame->intervals; *interval; ++interval) {
                    // allow a fps rate of zero to mean ""accept first rate available""
                    if (10000000 / *interval == (unsigned int) fps || fps == 0) {

                        /* get the max values -- we need the interface number to be able
                        to do this */
                        ctrl->bInterfaceNumber = stream_if->bInterfaceNumber;
                        ret = usbhost_uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_MAX);
                        if (ret != UVC_SUCCESS) {
                            return ret;
                        }

                        ctrl->bmHint = (1 << 0); /* don't negotiate interval */
                        ctrl->bFormatIndex = format->bFormatIndex;
                        ctrl->bFrameIndex = frame->bFrameIndex;
                        ctrl->dwFrameInterval = *interval;

                        goto found;
                    }
                }
            } else {
                uint32_t interval_100ns = 10000000 / fps;
                uint32_t interval_offset = interval_100ns - frame->dwMinFrameInterval;

                if (interval_100ns >= frame->dwMinFrameInterval
                    && interval_100ns <= frame->dwMaxFrameInterval
                    && !(interval_offset
                         && (interval_offset % frame->dwFrameIntervalStep))) {

                    /* get the max values -- we need the interface number to be able
                    to do this */
                    ctrl->bInterfaceNumber = stream_if->bInterfaceNumber;
                    ret = usbhost_uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_MAX);
                    if (ret != UVC_SUCCESS) {
                        return ret;
                    }

                    ctrl->bmHint = (1 << 0);
                    ctrl->bFormatIndex = format->bFormatIndex;
                    ctrl->bFrameIndex = frame->bFrameIndex;
                    ctrl->dwFrameInterval = interval_100ns;

                    goto found;
                }
            }
        }
    }

    return UVC_ERROR_INVALID_MODE;

    found:
    return usbhost_uvc_probe_stream_ctrl(devh, ctrl);
}

/** Get a negotiated streaming control block for some common parameters for all interface
* @ingroup streaming
*
* @param[in] devh Device handle
* @param[in,out] ctrl Control block
* @param[in] format_class Type of streaming format
* @param[in] width Desired frame width
* @param[in] height Desired frame height
* @param[in] fps Frame rate, frames per second
*/
uvc_error_t usbhost_get_stream_ctrl_format_size_all(
        usbhost_uvc_device *devh,
        uvc_stream_ctrl_t *ctrl,
        uint32_t fourcc,
        int width, int height,
        int fps
) {
    usbhost_uvc_streaming_interface_t *stream_if;
    uvc_format_desc_t *format;
    uvc_error_t ret = UVC_SUCCESS;

    DL_FOREACH(devh->deviceData.stream_ifs, stream_if) {

        DL_FOREACH(stream_if->format_descs, format) {
            uvc_frame_desc_t *frame;

            if (SWAP_UINT32(fourcc) != *(const uint32_t *) format->guidFormat)
                continue;

            DL_FOREACH(format->frame_descs, frame) {
                if (frame->wWidth != width || frame->wHeight != height)
                    continue;

                uint32_t *interval;

                if (frame->intervals) {
                    for (interval = frame->intervals; *interval; ++interval) {
                        // allow a fps rate of zero to mean ""accept first rate available""
                        if (10000000 / *interval == (unsigned int) fps || fps == 0) {

                            /* get the max values -- we need the interface number to be able
                            to do this */
                            ctrl->bInterfaceNumber = stream_if->bInterfaceNumber;
                            ret = usbhost_uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_MAX);
                            if (ret != UVC_SUCCESS) {
                                return ret;
                            }

                            ctrl->bmHint = (1 << 0); /* don't negotiate interval */
                            ctrl->bFormatIndex = format->bFormatIndex;
                            ctrl->bFrameIndex = frame->bFrameIndex;
                            ctrl->dwFrameInterval = *interval;

                            goto found;
                        }
                    }
                } else {
                    uint32_t interval_100ns = 10000000 / fps;
                    uint32_t interval_offset = interval_100ns - frame->dwMinFrameInterval;

                    if (interval_100ns >= frame->dwMinFrameInterval
                        && interval_100ns <= frame->dwMaxFrameInterval
                        && !(interval_offset
                             && (interval_offset % frame->dwFrameIntervalStep))) {

                        /* get the max values -- we need the interface number to be able
                        to do this */
                        ctrl->bInterfaceNumber = stream_if->bInterfaceNumber;
                        ret = usbhost_uvc_query_stream_ctrl(devh, ctrl, 1, UVC_GET_MAX);
                        if (ret != UVC_SUCCESS) {
                            return ret;
                        }

                        ctrl->bmHint = (1 << 0);
                        ctrl->bFormatIndex = format->bFormatIndex;
                        ctrl->bFrameIndex = frame->bFrameIndex;
                        ctrl->dwFrameInterval = interval_100ns;

                        goto found;
                    }
                }
            }
        }
    }

    return UVC_ERROR_INVALID_MODE;

    found:
    return usbhost_uvc_probe_stream_ctrl(devh, ctrl);
}

/**
* @brief Get the length of a control on a terminal or unit.
*
* @param devh UVC device handle
* @param unit Unit or Terminal ID; obtain this from the uvc_extension_unit_t describing the extension unit
* @param ctrl Vendor-specific control number to query
* @return On success, the length of the control as reported by the device. Otherwise,
*   a uvc_error_t error describing the error encountered.
* @ingroup ctrl
*/
int uvc_get_ctrl_len(usbhost_uvc_device *devh, uint8_t unit, uint8_t ctrl) {
    unsigned char buf[2];

    if (!devh)
        return UVC_ERROR_NO_DEVICE;

    int ret = usb_device_control_transfer(
            devh->device->get_handle(),
            UVC_REQ_TYPE_GET,
            UVC_GET_LEN,
            ctrl << 8,
            unit << 8 | devh->deviceData.ctrl_if.bInterfaceNumber,
            buf,
            2, 0);

    if (ret < 0)
        return ret;
    else
        return (unsigned short) SW_TO_SHORT(buf);
}

/**
* @brief Perform a GET_* request from an extension unit.
*
* @param devh UVC device handle
* @param unit Unit ID; obtain this from the uvc_extension_unit_t describing the extension unit
* @param ctrl Control number to query
* @param data Data buffer to be filled by the device
* @param len Size of data buffer
* @param req_code GET_* request to execute
* @return On success, the number of bytes actually transferred. Otherwise,
*   a uvc_error_t error describing the error encountered.
* @ingroup ctrl
*/
int uvc_get_ctrl(usbhost_uvc_device *devh, uint8_t unit, uint8_t ctrl, void *data, int len,
                 enum uvc_req_code req_code) {
    if (!devh)
        return UVC_ERROR_NO_DEVICE;

    return usb_device_control_transfer(
            devh->device->get_handle(),
            UVC_REQ_TYPE_GET, req_code,
            ctrl << 8,
            unit << 8 | devh->deviceData.ctrl_if.bInterfaceNumber,        // XXX saki
            static_cast<unsigned char *>(data),
            len, 0);
}

/**
* @brief Perform a SET_CUR request to a terminal or unit.
*
* @param devh UVC device handle
* @param unit Unit or Terminal ID
* @param ctrl Control number to set
* @param data Data buffer to be sent to the device
* @param len Size of data buffer
* @return On success, the number of bytes actually transferred. Otherwise,
*   a uvc_error_t error describing the error encountered.
* @ingroup ctrl
*/
int uvc_set_ctrl(usbhost_uvc_device *devh, uint8_t unit, uint8_t ctrl, void *data, int len) {
    if (!devh)
        return UVC_ERROR_NO_DEVICE;
    auto ret = usb_device_control_transfer(
            devh->device->get_handle(),
            UVC_REQ_TYPE_SET, UVC_SET_CUR,
            ctrl<<8,
            unit << 8 | devh->deviceData.ctrl_if.bInterfaceNumber,
            static_cast<unsigned char *>(data),
            len, 10);
    int x =errno;
    return ret;
}

uvc_error_t uvc_get_power_mode(usbhost_uvc_device *devh, enum uvc_device_power_mode *mode,
                               enum uvc_req_code req_code) {
    uint8_t mode_char;
    int ret;
    if (!devh)
        return UVC_ERROR_NO_DEVICE;

    ret = usb_device_control_transfer(
            devh->device->get_handle(),
            UVC_REQ_TYPE_GET, req_code,
            UVC_VC_VIDEO_POWER_MODE_CONTROL << 8,
            devh->deviceData.ctrl_if.bInterfaceNumber,
            (unsigned char *) &mode_char,
            sizeof(mode_char), 0);

    if (ret == 1) {
        *mode = static_cast<uvc_device_power_mode>(mode_char);
        return UVC_SUCCESS;
    } else {
        return static_cast<uvc_error_t>(ret);
    }
}

uvc_error_t uvc_set_power_mode(usbhost_uvc_device *devh, enum uvc_device_power_mode mode) {
    uint8_t mode_char = mode;
    int ret;

    if (!devh)
        return UVC_ERROR_NO_DEVICE;

    ret = usb_device_control_transfer(
            devh->device->get_handle(),
            UVC_REQ_TYPE_SET, UVC_SET_CUR,
            UVC_VC_VIDEO_POWER_MODE_CONTROL << 8,
            devh->deviceData.ctrl_if.bInterfaceNumber,
            (unsigned char *) &mode_char,
            sizeof(mode_char), 0);

    if (ret == 1)
        return UVC_SUCCESS;
    else
        return static_cast<uvc_error_t>(ret);
}

// Iterate over all descriptors and parse all Interface and Endpoint descriptors
void usbhost_uvc_parse_config_descriptors(usb_descriptor_iter *it,
                                          usbhost_uvc_interfaces **interfaces) {

    usbhost_uvc_interfaces *descInterfaces = new usbhost_uvc_interfaces();
    memset(descInterfaces, 0, sizeof(usbhost_uvc_interfaces));
    usbhost_uvc_interface *curInterface = NULL;
    usb_interface_descriptor *curDescriptor = NULL;
    descInterfaces->numInterfaces = 0;


    // iterate over all descriptors
    usb_descriptor_header *h = nullptr;
    usb_descriptor_header *prev = nullptr;
    do {
        h = usb_descriptor_iter_next(it);
        if (h == NULL) {
            if (prev) {
                curInterface->extraLength = reinterpret_cast<unsigned char *>(it->config_end) -
                                            reinterpret_cast<unsigned char *>(prev);
                curInterface->extra =
                        reinterpret_cast<unsigned char *>(prev) + sizeof(usb_interface_descriptor);
                //LOG_DEBUG(""Saved extra length in end: %d"", curInterface->extraLength);
            }
        } else if (h->bDescriptorType == USB_DT_INTERFACE) {
            curDescriptor = (usb_interface_descriptor *) h;
            if (prev != nullptr) {
                curInterface->extraLength = reinterpret_cast<unsigned char *>(curDescriptor) -
                                            reinterpret_cast<unsigned char *>(prev);
                curInterface->extra =
                        reinterpret_cast<unsigned char *>(prev) + sizeof(usb_interface_descriptor);
                //LOG_DEBUG(""Saved extra length: %d"", curInterface->extraLength);
            }
            prev = h;
            curInterface = &descInterfaces->iface[curDescriptor->bInterfaceNumber];
            memcpy(&curInterface->desc, curDescriptor, curDescriptor->bLength);
            curInterface->winusbInterfaceNumber = descInterfaces->numInterfaces;
            //LOG_DEBUG(""Found interface number %d "",curDescriptor->bInterfaceNumber);
            descInterfaces->numInterfaces++;
        } else if (h->bDescriptorType == USB_DT_ENDPOINT) {
            memcpy(&curInterface->endpoints[curInterface->numEndpoints], h, h->bLength);
            /*LOG_DEBUG(""Found endpoint: %x for interface number %d "",
                 curInterface->endpoints[curInterface->numEndpoints].bEndpointAddress,
                 curInterface->winusbInterfaceNumber);*/
            curInterface->numEndpoints++;
        }
    } while (h);
    //LOG_DEBUG(""Finished parsing descriptors!"");
    *interfaces = descInterfaces;
}


usb_descriptor_header *
usbhost_get_descriptor(usb_device *pDevice, int descriptor_type, int descriptor_index) {
    int curr_index = 0;
    usb_descriptor_iter iter;
    usb_descriptor_iter_init(pDevice, &iter);
    usb_descriptor_header *h = usb_descriptor_iter_next(&iter);
    while (h != nullptr) {
        if (h->bDescriptorType == descriptor_type) {
            if (curr_index == descriptor_index) {
                return h;
            } else {
                curr_index++;
            }
        }
        h = usb_descriptor_iter_next(&iter);
    }
    return h;
}

uvc_error_t usbhost_open(usbhost_uvc_device *device, int InterfaceNumber) {
    usbhost_uvc_interfaces *interfaces = NULL;
    usb_config_descriptor *cfgDesc = NULL;
    byte *descriptors = NULL;
    uvc_error_t ret = UVC_SUCCESS;

    //LOG_DEBUG(""usbhost_open() device: %s"", device->deviceHandle->dev_name);
    device->streams = NULL;

    // Start by clearing deviceData, otherwise
    // usbhost_uvc_free_device_info(&device->deviceData);
    // will do something not good
    memset(&device->deviceData, 0, sizeof(usbhost_uvc_device_info_t));

    if (!device->device) {
        LOG_ERROR(""usb_device_new() failed to create usb device!"");
        ret = UVC_ERROR_INVALID_PARAM;
        goto fail;
    }


    // Returns IVCAM configuration descriptor
    cfgDesc = (usb_config_descriptor *) usbhost_get_descriptor(device->device->get_handle(),
                                                               USB_DT_CONFIG,
                                                               0);
    if (cfgDesc == NULL) {
        LOG_ERROR(""usb_device_new() failed cannot get config descriptor!"");
        ret = UVC_ERROR_INVALID_PARAM;
        goto fail;
    }
    device->deviceData.config = *cfgDesc;
    //LOG_DEBUG(""usbhost_open() parsing descriptors: %s"", device->deviceHandle->dev_name);
    // Iterate over all descriptors and parse all Interface and Endpoint descriptors
    usb_descriptor_iter it;
    usb_descriptor_iter_init(device->device->get_handle(), &it);
    usbhost_uvc_parse_config_descriptors(&it,
                                         &interfaces);
    //LOG_DEBUG(""usbhost_open() parsing descriptors complete found %d interfaces"",interfaces->numInterfaces);

    device->deviceData.interfaces = interfaces;


    //LOG_DEBUG(""usbhost_open() usbhost_uvc_scan_control"");

    // Fill fields of uvc_device_info on device
    ret = usbhost_uvc_scan_control(device, &device->deviceData, InterfaceNumber);
    if (ret != UVC_SUCCESS) {
        LOG_ERROR(""uvc_scan_control failed\\n"");
        goto fail;
    }

    return ret;

    fail:

    if (descriptors) {
        delete descriptors;
    }

    if (device) {
        usbhost_uvc_free_device_info(&device->deviceData);

        if (device->device) {
            device->device = NULL;
        }
    }
    LOG_ERROR(""usbhost_open() failed! "" << ret);
    return ret;
}


uvc_error_t usbhost_close(usbhost_uvc_device *device) {
    uvc_error_t ret = UVC_SUCCESS;

    if (device != NULL) {
        usbhost_uvc_free_device_info(&device->deviceData);
        memset(&device->deviceData, 0, sizeof(usbhost_uvc_device_info_t));


        if (device->device) {
            //usb_device_close(device->deviceHandle->GetHandle()); //TODO: do we need to do this?
            device->device = NULL;
        }

        device->streams = NULL;
        free(device);
    } else {
        printf(""Error: device == NULL\\n"");
        ret = UVC_ERROR_NO_DEVICE;
    }

    return ret;
}
#endif
",16141,True,2717.6452057539864,median
"= Elements of FlashForth 5
Peter Jacobs, Pete Zawasky and Mikael Nordman
2021-12-30
:toc: right
:stylesheet: ./readthedocs.css
:sectnums:
:imagesdir: ../figs
:stem: latexmath
:eqnums:

This document is a remix of material from a number of Forth tutorials and references, 
adapted to the FlashForth 5 environment.
It provides some examples and explanation of using FlashForth on a PIC18 microcontroller
while concentrating on the features of the language rather than the details of the
microcontroller hardware.
Following an introduction to the FlashForth interpreter, 
we look at adding our own word definitions to the dictionary and then explore
the manipulation of data values on the stack.
Flow of program control and more advanced defining words are also explored.
These defining words are convenient for making arrays.
Finally, strings and formatted numeric output are discussed.

:leveloffset: +1

= Introduction

Forth is an interesting mix of low-level access tools and language building tools.
It is effectively a small toolkit with which you construct a specialized dictionary of words
that work together to form your application code.
This tutorial will explore and explain the workings of the FlashForth 5 toolkit
running on a Microchip PIC18 microcontroller
and complements the more hardware-oriented tutorial,
the FlashForth quick reference and the https://flashforth.com[FlashForth website].
Our interest is in using Forth on the microcontroller in an embedded system,
such as a special-purpose signal timing device,
rather than as part of a general-purpose calculation on a personal computer.

There are quite a number of 
good introductory tutorials^<<brodie_1987,1>>,<<noble_2001,4>>^, 
course notes^<<pelc_2011,5>>^, and references^<<conklin_2007,3>>^ 
for programming in Forth on a desktop or laptop computer,
however, FlashForth running on a PIC18 microcontroller is a different environment.
In the following sections, 
we will follow closely J.V. Noble's tutorial^<<noble_2001,4>>^
for using Forth on a personal computer,
reusing many of his examples and explanations verbatim, 
while adapting the overall tutorial to the use of FlashForth on a microcontroller.

= Getting started

Although we will be using FlashForth on a PIC18 microcontroller, we communicate with it
using a serial terminal program running on a personal computer.
FlashForth comes with a couple of terminal programs (in Python and Tcl/Tk)
that have some conveniences when sending files to the microcontroller,
so we will start our interaction with one of those.
Starting the `ff-shell.tcl` program in a normal terminal window
will start up the Tcl/Tk shell program.
Pressing the `Enter` key &#x23CE; a couple of times should get the display 
as shown in Figure 1.
The `ok<#,ram>` prompt indicates that the current base is ten,
for representing numbers in decimal format, 
and that the current context for making variables is static RAM, 
rather than the Flash memory and EEPROM that is also available in the microcontroller.

.Opening screen using `ff-shell.tcl`.
[#opening_screen]
image::ff5-start-screen-ff-shell-tcl.png[width=80%]

In contrast to Forth on a PC, FlashForth is case sensitive,
with most predefined words being spelled with lower case.
Also, being intended for use in an embedded system, there is no command to exit the system.
FlashForth only stops when the power is removed or a reset occurs.

= The interpreter

FlashForth is an interactive programming language consisting of _words_.
Forth words are the equivalent of subroutines or functions in other languages and are
executed by naming them.
Although FlashForth is interactive at its core, the user doesn't need to
interact with an embedded application if its top-level word is set to automatically
execute at power-up.

Here is an example of executing a FlashForth word: +
`hex` &#x23CE;  `ok<$,ram>` +
This executes the word that sets the base for representing numbers to 16, 
a format that you are likely to be familiar with
if you are a student of mechatronics or computing.
Note that both the text that your typed and the FlashForth response is shown
together, on either side of the `Enter` symbol &#x23CE;.
For the moment, let's return to using decimal numbers: +
`decimal` &#x23CE; `  ok<#,ram>`

Now, let's try something a bit more interesting by entering: +
`2 17 + .` &#x23CE; `19 <#,ram>` +
This time FlashForth more clearly shows its interpretive nature.
A small program called the _outer interpreter_ continually loops,
waiting for input from the serial port.
The input is a sequence of text strings (words or numbers) separated from each other
by the standard Forth delimiter, one or more ASCII blank characters.

The text strings are interpreted in only three ways: words (subroutine or function names),
numbers, or _not defined_.
The outer interpreter tries first to look for the incoming word in the _dictionary_
that contains the already defined words.
If it finds the word, it executes the corresponding code.

If no dictionary entry exists, the interpreter tries to read the input as a number.  
If the string satisfies the rules for defining a number, it is converted to a number
in the microcontroller's internal representation, and stored in a special memory location,
called the _top of stack_ (`TOS`).

In the example above, FlashForth interpreted 2 and 17 as numbers,
and pushed them onto the stack.
`+` is a predefined word, as is `.`, so they are looked up and executed.
The `+` (plus) word removed `2` and `17` from the stack, added them together, 
and left the result `19` on the stack. 
The word `.` (dot) removed `19` from the stack and sent it to the standard output device,
the serial port for FlashForth.
Here is a picture of the stack through the process.
The second-top element of the stack is labelled `NOS` for _next on stack_. +
[cols=6,options=""header""]
|===
| word executed 
|
| `2`
| `17`
| `+`
| `.`

| stack result
| `TOS`
| `2`
| `17`
| `19`
| &#x23B5;

|
| `NOS`
| &#x23B5;
| `2`
| &#x23B5;
|

|
|
|
| &#x23B5;
|
|
|===

We might also work in hexadecimal: +
`hex 0a 14 * .` &#x23CE; `c8 <$,ram>` +
This number base is probably convenient for most embedded systems work,
where setting and monitoring bit patterns forms a large part of the code.
If you want to explicitly indicate the base of a number, you can prepend a sigil to the
digits of the number.
For example, `$10`, `#16` and `%10000` all represent the decimal value sixteen.

If the incoming text cannot be located in the dictionary nor interpreted as a number,
FlashForth issues an error message. +
`$0A` &#x23CE; `$0A ?` +
`thing` &#x23CE; `thing ?` +
Note that the apparent hexadecimal number `$0A` was not interpreted as such 
because of the case sensitivity of FlashForth. +
`decimal $0a` &#x23CE; `ok<#,ram>10` +
This time, the hexadecimal number was recognized and its value appears on the stack,
which is printed (in base ten) after the `ok` response.
To assist with the handling of numbers with many digits,
FlashForth allows the convenience of embedding periods into the text of the number.
This is most useful for binary numbers, but it works generally. +
`hex` &#x23CE; `ok<$,ram>` +
`%0100.0000.0000.0000` &#x23CE; `ok<$,ram>4000` +
`$4000` &#x23CE; `ok<$,ram>4000 4000` +
`$4.0.0.0` &#x23CE; `ok<$,ram>4000 4000 4000` +
`$4.` &#x23CE; `ok<$,ram>4000 4000 4000 4 0` +
`decimal` &#x23CE; `ok<#,ram>16384 16384 16384 4 0` +
Note that the period after the number resulted in a double value being placed 
on the stack as two (separate) items.

Other error messages that you might see include `SP ?`, for a stack pointer error, 
and `CO ?`, for a context error.
If the word {asterisk} was to be executed without there being at least two numbers sitting 
on the stack, the interpreter would abort, issuing the `SP` error message, 
and then wait for new input. +
`*` &#x23CE; `ok<#,ram> SP?` 

Finally, to show the compilation and use of a new word,
here is the classic _Hello World!_ program. +
`: hey ."" Hello, World!"" ;` &#x23CE; `ok<#,ram>` +
Forth lets you output text using the word `.""` while the words `:` and `;`
begin and end the definition of your own word `hey`.
Note that blank characters are used to delimit each of these words.
Now, type in `hey` and see what happens. +
`hey` &#x23CE; `Hello, World! ok<#,ram>`

= Extending the dictionary

// It seems that ASCIIdoc has a special form of quoting hell.
// The following lines occasionally put a backslash in front of the asterisk
// that represents multiply in the bits of quoted text.
// This is to stop it being interpreted as ""start bold"".

Forth belongs to the class of Threaded Interpretive Languages.
This means that it can interpret commands typed at the console,
as well as compile new subroutines and programs.
The Forth compiler is part of the language and special words are
used to make new dictionary entries (_i.e._ words).
The most important are `:` (start a new definition) and
`;` (terminate the definition).
Let's try this out by typing: +
`: \\*+  *  +  ;` &#x23CE; `ok<#,ram>` +
What happened?
The action of `:` is to create a new dictionary entry named `*+` and 
switch from _interpret_ to _compile_ mode.
In compile mode, the interpreter looks up words and, rather than executing them,
installs pointers to their code.
If the text is a number, instead of pushing it onto the stack, FlashForth builds
the number into the dictionary space allotted for the new word, 
following special code that puts the stored number onto the stack whenever the 
word is executed.
The run-time action of `\\*+` is thus to execute sequentially the previously-defined words
`*` and `+`

The word `;` is special.  
It is an _immediate_ word and is always executed, even if the system is in compile mode.
What `;` does is twofold.
First, it installs the code that returns control to the next outer level 
of the interpreter and, second, it switched back from compile mode to interpret mode.

Now, try out your new word: +
`5 6 7 *+ .` &#x23CE; `47 ok<#,ram>` +
This example illustrated two principal activities of working in Forth:
adding a new word to the dictionary, and trying it out as soon as it was defined.

Note that, in FlashForth, names of dictionary entries are limited to 15 characters.
Also, FlashForth will not redefine a word that already exists in the dictionary.
This can be convenient as you build up your library of Forth code because it allows
you to have repeated definitions, say for special function registers, in several files
and not have to worry about the repetition.

== Dictionary management

The word `empty` will remove all dictionary entries that you have made and
reset all memory allocations to the original values of the core FlashForth interpreter.
As you develop an application, it will often be convenient to return to an earlier,
intermediate dictionary and memory allocation state. 
This can be done with the word `marker`.
For example, we could issue the command
----
marker -my-mark
----
Later, after we have done some work with the FlashForth system and 
defined a few of our own words and variables,
we can return the dictionary and memory allocation to the earlier state
by executing the word `-my-mark`.
Here, we have arbitrarily chosen the word `-my-mark` 
so it would be good to choose a word that has
some specific and easily remembered meaning for us.

= Stacks and reverse Polish notation

The stack is the Forth analog of a pile of cards with numbers written on them.
The numbers are always added to the top of the pile, and removed from the top of the pile.
FlashForth incorporates two stacks: the parameter stack and the return stack,
each consisting of a number of cells that can hold 16-bit numbers.

The Forth input line +
`decimal 2 5 73 -16` &#x23CE; +
leaves the parameter stack in the state +
[cols=3,options=""header""]
|===
| cell number 
| content 
| comment

| 0 
| `-16` 
| `TOS` (Top Of Stack)

|1 
| `73` 
| `NOS` (Next On Stack)

| 2 
| `5`
|

| 3 
| `2`
|

|
| &#x23B5;
|
|===
We will usually employ zero-based relative numbering in Forth data structures
such as stacks, arrays and tables.
Note that, when a sequence of numbers is entered like this, the right-most number
becomes TOS and the left-most number sits at the bottom of the stack.

Suppose that we followed the original input line with the line +
`+ - * .` &#x23CE; +
to produce a value _xxx_.
What would the _xxx_ be?
The operations would produce the successive stacks: +
[cols=7,options=""header""]
|===
| word executed
|
|
| `+`
| `-`
| `*`
| `.`

| stack result
| `TOS`
| `-16`
| `57`
| `-52`
| `-104`
| &#x23B5;

|
| `NOS`
| `73`
| `5`
| `2`
| &#x23B5;
|

|
|
| `5`
| `2`
| &#x23B5;
|
|

|
|
| `2`
| &#x23B5;
|
|
|

|
|
| &#x23B5;
|
|
|
|

|===

So, after both lines, the terminal window shows
----
decimal 2 5 73 -16  ok<#,ram>2 5 73 65520 
+ - * . -104  ok<#,ram>
----
Note that FlashForth conveniently displays the stack elements on interpreting each line 
and that the value of -16 is displayed as the 16-bit unsigned integer 65520.
Also, the word `.` consumes the -104 data value, leaving the stack empty.
If we execute `.` on the now-empty stack, the outer interpreter aborts with
a stack pointer error (`SP ?`).

The programming notation where the operands appear first,
followed by the operator(s) is called reverse Polish notation (RPN).
It will be familiar to students who own RPN calculators made by Hewlett-Packard.


== Manipulating the parameter stack

Being a stack-based system, FlashForth must provide ways to put numbers onto the stack,
to remove them and to rearrange their order.
We've already seen that we can put numbers onto the stack by simply typing the number.
We can also incorporate the number into the definition of a Forth word.

The word `drop` removes a number from the TOS thus making NOS the new TOS.
The word `swap` exchanges the top 2 numbers.
`dup` copies the TOS into NOS, pushing all of the other numbers down.
`rot` rotates the top 3 numbers, bring the number that was just below NOS to the TOS.
These actions are shown below.

[cols=7,options=""header""]
|===
| word executed
|
|
| `drop`
| `swap`
| `rot`
| `dup`

| stack result
| TOS
| `-16`
| `73`
| `5`
| `2`
| `2`

|
| NOS
| `73`
| `5`
| `73`
| `5`
| `2`

|
|
| `5`
| `2`
| `2`
| `73`
| `5`

|
|
| `2`
| &#x23B5;
| &#x23B5;
| &#x23B5;
| `73`

|
|
| &#x23B5;
|
|
|
| &#x23B5;

|===

FlashForth also includes the words `over`, `tuck` and `pick` that act as shown below.
`over` makes a copy of NOS and then leaves it as the new TOS.
`tuck` make a copy of the TOS and inserts the copy just below the NOS.
Note that `pick` must be preceeded by an integer that (gets put on the stack briefly and) 
says where on the stack an element gets picked.
Also, for the PIC18 version of FlashForth, 
the definition of `pick` is provided as Forth source code in the file `pick.fs`.
The content of this file must be sent to the microcontroller to define the word before we try to use it. 

[cols=6,options=""header""]
|===
| word executed
|
|
| `over`
| `tuck`
| `4 pick`

| stack result
| TOS
| `-16`
| `73`
| `73`
| `5`

|
| NOS
| `73`
| `-16`
| `-16`
| `73`

|
|
| `5`
| `73`
| `73`
| `-16`

|
|
| `2`
| `5`
| `73`
| `73`

|
|
| &#x23B5;
| `2`
| `5`
| `73`

|
|
|
| &#x23B5;
| `2`
| `5`

|
|
|
|
| &#x23B5;
| `2`

|
|
|
|
|
| &#x23B5;

|===

From these actions, we can see that `0 pick` is the same as `dup`,
`1 pick` is a synonym for `over`.
The word `pick` is mainly useful for dealing with deep stacks, however,
you should avoid making the stack deeper than 3 or 4 elements.
If you are finding that you often have to reason about deeper stacks, 
consider how you might refactor your program.

Double length (32-bit) numbers can also be handled in FlashForth.
A double number will sit on the stack as a pair of 16-bit cells, 
with the cell containing the least-significant 16-bits 
sitting below the cell containing the most-significant 16-bits. 
The words for manipulating pairs of cells on the parameter stack are
`2dup`, `2swap`, `2over` and `2drop`.
For example, we can put a double value onto the stack by putting a period
as the last character of the number literal. +
`hex 23.` &#x23CE; `ok<$,ram>23 0` 

Memory on microcontrollers is limited and,
for FlashForth on the PIC18, the parameter stack is limited to 26 cells.
If you accumulate too many items on the stack, 
it will overflow and the interpreter will abort.
The stack will be emptied and the interpreter will wait for further input.


== The return stack and its uses

During compilation of a new word, FlashForth establishes links from the calling word
to the previously-defined words that are to be invoked by execution of the new word.
This linkage mechanism, during execution, uses the return stack (rstack).
The address of the next word to be invoked is placed on the rstack so that,
when the current word is done executing, the system knows where to jump 
to the next word.
Since words can be nested, there needs to be a stack of these return addresses.

In addition to serving as the reservoir of return addresses, 
the return stack is where the counter for the `for ... next` construct is placed.
(See the section on looping.)
The user can also store to and retrieve from the rstack but this must be done carefully
because the rstack is critical to program execution.
If you use the rstack for temporary storage, you must return it to its original state,
or else you will probably crash the FlashForth system.
Despite the danger, there are times when use of the rstack as temporary storage can make
your code less complex.

To store to the rstack, use `>r` to move TOS from the parameter stack 
to the top of the rstack.
To retrieve a value, `r>` moves the top value from the rstack 
to the parameter stack TOS.
To simply remove a value from the top of the rstack there is the word `rdrop`.
The word `r@` copies the top of the rstack to the parameter stack TOS 
and is used to get a copy of the loop counter in a `for` loop 
discussed in the section on looping. 


= Using memory

As well as static RAM, the PIC18 microcontroller has program memory, or Flash memory,
and also EEPROM.
Static RAM is usually quite limited on PIC18 controllers and the data stored there is
lost if the MCU loses power.
The key attribute of RAM is that it has an unlimited endurance for being rewritten.
The Flash program memory is usually quite a bit larger and is retained, 
even with the power off.
It does, however, have a very limited number of erase-write cycles that it can endure.
EEPROM is also available, in even smaller amounts than static RAM and is non-volatile.
It has a much better endurance than Flash, but any particular cell 
is still limited to about 100000 rewrites.
It is a good place to put variables that you change occasionally but 
must retain when the power is off.
Calibration or configuration data may be an example of the type of data 
that could be stored in EEPROM.
The registers that configure, control and monitor the microcontroller's peripheral devices 
appear as particular locations in the static RAM memory.

In FlashForth, 16-bit numbers are fetched from memory to the stack by the word `@` (fetch)
and stored from TOS to memory by the word `!` (store).
`@` expects an address on the stack and replaces the address by its contents.
`!` expects a number (NOS) and an address (TOS) to store it in.
It places the number in the memory location referred to by the address, 
consuming both parameters in the process.

Unsigned numbers that represent 8-bit (byte) values can be placed in character-sized cells
of memory using `c@` and `c!`.
This is convenient for operations with strings of text, but is especially useful
for handling the microcontroller's peripheral devices via their special-function
file registers.
For example, data-latch register for port B digital input-output 
is located at address `$ff8a` 
and the corresponding tristate-control register at address `$ff93`.
We can set pin RB0 as an output pin by setting the corresponding bit in the 
tristate control register to zero. +
`%1111.1110 $ff93 c!` &#x23CE; `ok<$,ram>` +
and then set the pin to a digital-high value by writing a 1 to the port's latch register +
`1 $ff8a c!` &#x23CE; `ok<$,ram>` +
If we had a light-emitting diode attached to this pin, via a current-limiting resistor,
we should now see it light up as in the companion hardware tutorial.
Here is what the terminal window contains after turning the LED on and off a couple of times.
----
warm 
S FlashForth 5 PIC18F26K22 11.11.2016

%1111.1110 $ff93 c!  ok<#,ram>
1 $ff8a c!  ok<#,ram>
0 $ff8a c!  ok<#,ram>
1 $ff8a c!  ok<#,ram>
0 $ff8a c!  ok<#,ram>
----
Note that we started the exercise with a _warm_ restart so that the FlashForth
environment was in a known good state.
Being interactive, FlashForth allows you to play with the hardware very easily.


== Variables

A variable is a named location in memory that can store a number,
such as the intermediate result of a calculation, off the stack.
For example, +
`variable x` &#x23CE; `ok<#,ram>` +
creates a named storage location, `x` which executes by leaving the address
of its storage location as TOS: +
`x` &#x23CE; `ok<#,ram>61806` +
We can then fetch from or store to this address as described in the previous section.
----
empty warm 
S FlashForth 5 PIC18F26K22 11.11.2016

marker -play  ok<#,ram>
variable x  ok<#,ram>
3 x !  ok<#,ram>
x @ . 3  ok<#,ram>
----
For FlashForth, the dictionary entry, `x`, 
is in the Flash memory of the microcontroller but the
storage location for the number is in static RAM (in this instance).
Note that the `empty` word was used to discard all dictionary entries that
we may have made on top of the base system.
If you are unsure of what dictionary entries you have made, 
use `words` to display all current dictionary entries.

FlashForth provides the words `ram`, `flash` and `eeprom`
to change the memory context of the storage location.
Being able to conveniently handle data spaces in different
memory types is a major feature of FlashForth.
To make another variable in EEPROM, try +
`eeprom variable y` &#x23CE; `ok<#,eeprom>` +
We can access this new (nonvolatile) variable as we did for the RAM variable `x`,
but `y` retains its value, even when we turn off and on the power to the microcontroller.
----
4 y !  ok<#,eeprom>
y @ . 4  ok<#,eeprom>
x @ . 3  ok<#,eeprom>

 FlashForth 5 PIC18F26K22 11.11.2016

y @  ok<#,ram>4 
x @  ok<#,ram>4 0 
----
In the example above, we reset the microcontroller by bringing its MCLR pin low for a moment.

== Constants

A constant is a number that you would not want to change during a program's execution.
The addresses of the microcontroller's special-function registers are a good example 
of use and, because the constant numbers are stored in nonvolatile Flash memory, they are
available even after a hardware reset.
The result of executing the word associated with a constant is the data value being left on the stack.
----
$ff93 constant trisb  ok<#,ram> 
$ff8a constant latb  ok<#,ram>
%1111.1110 trisb c!  ok<#,ram>
0 latb c!  ok<#,ram>
1 latb c!  ok<#,ram>
0 latb c!  ok<#,ram>

 FlashForth 5 PIC18F26K22 11.11.2016

hex trisb   ok<$,ram>ff93 
%1111.1110 trisb c!  ok<$,ram>ff93 
0 latb c!  ok<$,ram>ff93 
1 latb c!  ok<$,ram>ff93 
----

== Values

A `value` is a hybrid type of variable and constant.
We define and initialize a value and invoke it as as we would for a constant.
We can also change a value as we can a variable.
----
decimal  ok<#,ram>
13 value thirteen  ok<#,ram>
thirteen  ok<#,ram>13 
47 to thirteen  ok<#,ram>13 
thirteen  ok<#,ram>13 47 
----
The word `to` also works within word definitions, replacing the value that
follows it with whatever is currently in TOS.
You must be careful that `to` is followed by a value and not something else.


== Basic tools for allocating memory

The words `create` and `allot` are the basic tools for setting aside memory
and attaching a convenient label to it.
For example, the following transcript shows a new dictionary entry `x` being created 
and an extra 16 bytes of memory being allotted to it.
----
empty warm 
S FlashForth 5 PIC18F26K22 11.11.2016

hex  ok<$,ram>
create x  ok<$,ram>
x u. f16e  ok<$,ram>
here u. f16e  ok<$,ram>
10 allot  ok<$,ram>
here u. f17e  ok<$,ram>
----
When executed, the word `x` will push the address of the first entry 
in its allotted memory space onto the stack.
The word `u.` prints an unsigned representation of a number and 
the word `here` returns the address of the next available space in memory.
In the example above, it starts with the same value as `x` but is incremented 
by (decimal) sixteen when we allotted the memory.

We can now access the memory allotted to `x` using the fetch and store words 
discussed earlier, in the section on memory.
To compute the address of the third byte allotted to `x` we could say `x 2 +`,
remembering that indices start at 0.
----
30 x 2 + c!  ok<$,ram>
x 2 + c@  ok<$,ram>30 
----
We will discuss a way to neatly package the snippets of code required to do the address
calculation later, in the section on creating arrays.
Finally, note that the memory context for this example has been the static RAM, however, 
(as shown for variables in the section on variables)
the context for allotting the memory can be changed.


= Comparing and branching

FlashForth lets you compare two numbers on the stack, using the relational
operators `>`, `<` and `=`.
----
hex  ok<$,ram>
2 3 =  ok<$,ram>0 
2 3 >  ok<$,ram>0 0 
2 3 <  ok<$,ram>0 0 ffff 
. -1  ok<$,ram>0 0 
----
These operators consume both arguments and leave a _flag_, 
to represent the boolean result.
Above, we see that ""2 is equal to 3"" is false (value 0),
""2 is greater than 3"" is also false, while
""2 is less than 3"" is true.
The true flag has all bits set to 1, hence the 16-bit hexadecimal representation `ffff`
and the corresponding signed representation `-1`.
FlashForth also provides the relational operators `0=` and `0<`
which test if the TOS is zero and negative, respectively.

The relational words are used for branching and control.
For example, after a warm restart, we can define the word `test` and try it
----
: test 0= invert if cr ."" Not zero!"" then ;  ok<#,ram>
0 test  ok<#,ram>
-14 test 
Not zero! ok<#,ram>
----
The TOS is compared with zero and the `invert` operator (ones complement) flips
all of the bits in the resulting flag.
If TOS is nonzero, the word `if` consumes the flag and executes all of the words
between itself and the terminating `then`.
If TOS is zero, execution jumps to the word following the `then`.
The word `cr` issues a carriage return (newline).

The word `else` can be used to provide an alternate path of execution as shown here.
----
: truth 0= if ."" false"" else ."" true"" then ;  ok<#,ram>
1 truth true ok<#,ram>
0 truth false ok<#,ram>
----
A nonzero TOS causes words between the `if` and `else` to be executed,
and the words between `else` and `then` to be skipped.
A zero value produces the opposite behaviour.

= Comments in Forth code

The word `(` -- a left parenthesis followed by a space -- 
says ""disregard all following text until the next right parenthesis 
or end-of-line in the input stream"".
Thus we can add explanatory comments to colon definitions.

Stack comments are a particular form of parenthesized remark which describes
the effect of a word on the stack.
For example the comment `( x -- x x)` could be used as the stack-effect comment 
for the word `dup`.
The comment indicates that the word will make a copy of TOS and add it to the stack,
leaving the original value, now as NOS.

The word `\\` (backslash followed by a space) is known as drop-line and is also
available as a method of including longer comments.
Upon executing, it drops everything from the input stream until the next carriage-return.
Instructions to the user, clarifications of usage examples can be conveniently expressed
in a block of text, with each line started by a backslash.


= Integer arithmetic operations

With FlashForth having 16-bit cells, the standard arithmetic operators 
shown in Table 1 below
operate on 16-bit signed integers, in the range `-32768` to `+32767` (decimal).
Note that the word `u*/mod` (scale) uses a 32-bit intermediate result.
FlashForth also provides arithmetic operators 
for double numbers (32-bit integers), signed and unsigned.
See the companion quick reference sheet for a more complete list.

.Arithmetic operators for single (16-bit) numbers.
[cols=3,options=""header""]
|===
| word 
| effect
| comment

| `+` 
| `( n1 n2 -- n1+n2)` 
| sum

| `-` 
| `( n1 n2 -- n1-n2)`
| difference 

| `*`
| `( n1 n2 -- n1*n2)`
| product

| `/`
| `( n1 n2 -- n1/n2)`
| quotient

| `mod`
| `( n1 n2 -- n.rem)`
| remainder

| `*/` 
| `( n1 n2 n3 -- n1*n2/n3)`
| scaled quotient

| `u/`
| `( u1 u2 -- u1/u2)`
| unsigned quotient

| `u/mod`
| `( u1 u2 -- rem quot)`
| remainder and quotient

| `u*/mod`
| `( u1 u2 u3 -- rem quot)`
| scaled remainder and quotient

|===

For an example of using arithmetic operators, consider the 
conversion of temperature values from Celcius to Fahrenheit 
using the formula `n2 = (n1*9/5 + 32)`.
----
decimal  ok<#,ram>
: to-f-1 ( n1 -- n2) 9 * 5 / #32 + ;  ok<#,ram>
0 to-f-1 . 32  ok<#,ram>
100 to-f-1 . 212  ok<#,ram>
500 to-f-1 . 932  ok<#,ram>
5000 to-f-1 . -4075  ok<#,ram>
----
This simple function works fine, up until the intermediate result
`(n1*9)` overflows the 16-bit cell.
With a bit more bother, we can make use of the scaled operator 
to avoid overflow of the intermediate result.
Again, the following function computes expression `(u1*9/5 + 32)`
but now uses the scale operator `*/`. 
This operator uses a 32-bit intermediate result to avoid overflow.
----
: to-f-2 ( n1 -- n2) 9 5 */ #32 + ;  ok<#,ram>
0 to-f-2 . 32  ok<#,ram>
100 to-f-2 . 212  ok<#,ram>
500 to-f-2 . 932  ok<#,ram>
5000 to-f-2 . 9032 ok<#,ram>  
----
Note that not all of the arithmetic operators are part of the core FlashForth
that is written in PIC18 assembly language and, to get the scale operator,
you will need to load the `math.fs` file of word definitions before
trying this second example.
This file is available in the common forth source directory of the FlashForth distribution.


= A little more on compiling

While compiling, it is possible to temporarily switch to interpreter mode
with the word `[` and switch back into compile mode with `]`.
The following example defines the word \\verb!feet! that converts a number
representing a length in feet to an equivalent number of millimetres.
The intermediate result is in tenths of a millimetre so that precision is retained and,
to make the conversion clear, the numeric conversion factor is computed
as we compile the word.
----
: feet ( u1 -- u2) 
  [ #254 #12 * ] literal #10 u*/mod 
  swap drop ;  ok<#,ram>
10 feet  ok<#,ram>3048 
----
The word `literal` is used to compile the data value in TOS 
into the definition of `feet`.
At run-time, that data value will be placed onto the stack.


= Looping and structured programming

The control words available for structured programming are shown in Table 2,
where `xxx` and `yyy` denote sequences of words and 
`cond` denotes a boolean flag value.
Within the body of a `for` loop, you may get the loop counter with the word `r@`.
It counts from _u_-1 down to 0.
If you `exit` from a for loop, you must drop the loop count with `rdrop`.

.Flow control in FlashForth.
[cols=2,options=""header""]
|===
| Code 
| Description

| _cond_ `if` _xxx_ `else` _yyy_ `then`
| Conditional execution.

| `begin` _xxx_ `again`
| Infinite loop.

| `begin` _xxx_ _cond_ `until`
| Loop until _cond_ is true.

| `begin` _xxx_ _cond_ `while` _yyy_ `repeat`
| Loop while _cond_ is true, _yyy_ is not executed on the last iteration.

| _u_ `for` _xxx_ `next` 
| Loop _u_ times.

| `endit` 
| Sets loop counter to zero so that we leave the loop when `next` is encountered.

| `exit` 
| Exit from a word.

|===

Here are a couple of examples of counted loops, 
one constructed from the generic `begin` ... `until` construct,
and the other using the dedicated `for` ... `next` construct.
Note the difference in counter ranges.
----
-countdown  ok<#,ram>
marker -countdown  ok<#,ram>
: countdown1 ( n --) 
  begin cr dup . 1- dup 0= until 
  drop ;  ok<#,ram>
5 countdown1 
5 
4 
3 
2 
1  ok<#,ram>
: countdown2 ( n --) 
  for cr r@ . next ;  ok<#,ram>
5 countdown2 
4 
3 
2 
1 
0  ok<#,ram>
----
It was convenient, when setting up these examples, to put the source code into a little file
that could be reloaded easily each time the source text was changed.
----
-countdown
marker -countdown
: countdown1 ( n --)
  begin cr dup . 1- dup 0= until
  drop ;
5 countdown1
: countdown2 ( n --)
  for cr r@ . next ;
5 countdown2
----

= More on defining words

The compiler word `create` makes a new dictionary entry 
using the next name in the input stream and compiles the pointer value 
of the first free location of the current data-space context.
When executed, the new dictionary entry leaves that pointer value on the stack.

`create` can be used to build other defining words.
For example, we can make our own variation of word `variable` as
----
: make-var create 1 cells allot ;  ok<#,ram>
----
Here `make-var` can be used to make an uninitialized variable that can hold a single number.
When `make-var` is executed, the first word within its definition (`create`)
sets up a dictionary entry with the name coming from the next text in the input stream
(`alpha` in the example below),
the number 1 is pushed onto the stack, the word `cells` converts the TOS to the 
appropriate number of bytes (2 in this case) and the word `allot` increments
the pointer to the next available space in memory by this number of bytes.
This allots one cell to the newly created _child_ word.
----
make-var alpha  ok<#,ram>
13 alpha !  ok<#,ram>
alpha @ . 13  ok<#,ram>
----
At run time for the newly created _child_ word, `alpha` leaves its data-space address 
on the stack and we may store to or fetch from this address, as shown above.

As a second example, we can also build a defining word for making initialized variables.
----
: make-zero-var create 0 , ;  ok<#,ram>
----
Instead of just allotting space for the data,
the word `,` (comma) puts TOS into the next cell of memory and increments
the memory-space pointer by appropriate number of bytes.
Run time use of the newly defined variable is the same as for any other variable.
----
make-zero-var beta  ok<#,ram>
beta @ . 0  ok<#,ram>
----

== create ... does&gt; ...

The word `does>` is used to specify a run-time action for the child words of
a defining word.
We can make our own variant of `constant` and test it.
----
: make-con create , does> @ ;  ok<#,ram>
53 make-con prime  ok<#,ram>
----
At run time for the defining word `make-con`, 
create sets up the new dictionary entry with the 
next text in the input stream (`prime`), the word `,` (comma) compiles TOS 
(53 in this example) into the memory-space of the new child word and 
`does>` stores the following words up to the terminating
semicolon (only `@` in this case), such that they will be executed at the run time
of the child word defined by `make-con`.
Thus, when `prime` is executed, the address of the first entry in its data-space 
is put onto the stack and the word `@` executed.
----
prime . 53  ok<#,ram>
----
Although only one word is stored as the run time code for `prime` in this example, 
it could be arbitrarily complex.

== Creating arrays

The `create` ... `does>` pair can be used to define some convenient 
array-defining words.
For an array of bytes, it is straight-forward to manually allot the
memory and address it at run time.
----
create my-array 10 allot  ok<#,ram>
my-array 10 $ff fill  ok<#,ram>
my-array @ .  -1  ok<#,ram>
----
Here, `my-array` is first allotted 10 bytes.
At run time for `my-array`, the address of the start of the 10 bytes is left on 
the stack, and we use the `fill` word (found in the Forth source file `core.fs`) 
to completely fill the array of bytes with ones.
Accessing the first cell (2 bytes) and printing it (to get `-1` sent to the serial port)
confirms that all bits are 1s.
The word `dump` can be used to get a more complete picture.
It expects the starting address and number of bytes to dump sitting on the stack.
----
hex  ok<$,ram>
my-array $30 dump 
f174 :ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ................
f184 :00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
f194 :00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ ok<$,ram>
----
Note that `dump` works with blocks of 16 bytes and that the dots to the right
show a character representation of the byte values.
This is convenient when trying to identify strings of text.

It is also straight-forward to create an array with particular data compiled in.
----
create my-cell-array 100 , 340 , 5 ,  ok<$,ram>
----
Remember to use `,` (comma) to compile in every data element, not leaving off the last one.
At run time, `my-cell-array` puts the address of the start of the associated memory
on the stack and the address of the desired cell (index 2, in this case) 
needs to be calculated (`2 cells +`) before executing `@` (fetch).
----
my-cell-array 2 cells + @ . 5  ok<$,ram>
----
This address calculation code can be added into the defining word with `does>`
such that the subsequently defined my-cells array will have the snippet of code 
(`swap cells +`) executed at run time to convert from a cell index to an address.
----
\\ A defining word for creating arrays.
: mk-cell-array ( u --) 
  create cells allot 
  does> swap cells + ;  ok<$,ram>
----
The `swap` is used to get the index as TOS with the array address as NOS,
`cells` scales the index to the offset as a number of bytes and `+` adds the
offset to the array address.
The newly computed cell address is left as TOS for use by the words `!` (store) and `@` (fetch). 
----
\\ Make an array and access it.
5 mk-cell-array my-cells  ok<$,ram>
3000 0 my-cells !  ok<$,ram>
3001 1 my-cells !  ok<$,ram>
3002 2 my-cells !  ok<$,ram>
1 my-cells @ . 3001  ok<$,ram>
----


== Jump tables

Sometimes we want to execute one of a large selection of words, 
depending on the outcome of a calculation.
It is possible to set up a sequence of tests and branches 
(as introduced in the section on comparing and branching), 
however, FlashForth allows a neater
solution in the form of a _jump table_.
A word in FlashForth can be executed by feeding its _execution token_
to the word `execute`.
If you have a table of execution tokens, then you need only look up the 
one corresponding to a given index, fetch it and say `execute`.
The following transcript shows such a jump-table for a collection of four functions,
the word `do-action` to execute the appropriate word, given an index,
and a sample of trials that shows the jump-table mechanism in action.
----
\\ Set up the words that we want to selectively execute.
: ring  ( --) ."" ring ring"" ;  ok<#,ram>
: open  ( --) ."" opening"" ;  ok<#,ram>
: laugh ( --) ."" ha ha"" ;  ok<#,ram>
: cry   ( --) ."" crying"" ;   ok<#,ram>

\\ Store the execution tokens in a table that allots into flash memory.
flash  ok<#,flash>
create actions ' ring , ' open , ' laugh , ' cry ,  ok<#,flash>
ram  ok<#,ram>

: do-action ( n --) 
  0 max 3 min 
  cells actions + @ execute ;  ok<#,ram>

\\ Call up the actions.
3 do-action crying ok<#,ram>
0 do-action ring ring ok<#,ram>
2 do-action ha ha ok<#,ram>
5 do-action crying ok<#,ram>
----
The word `'` (tick) finds the following name in the dictionary and
puts its execution token (xt) on the stack.  
The word `,` (comma) compiles the xt into the table.
Note that we are compiling these tokens into the flash memory of the microcontroller
so that the jump table continues to work, even after a power break.
In `do-action`, the words `0 max 3 min` limit the incoming index value to 
the valid range for looking up a token in the jump-table.
The token is fetched to TOS and then `execute` called.
The final line of the transcript shows that the word `cry` is executed for
the invalid index value of 5.
You may want to handle incorrect input differently in your application.

The FlashForth distribution comes with a file, `jmptbl.fs` 
(in the common forth source code directory),
that provides set of words for building jump tables.
With these words, we can build a second jump table with a neater notation.
----
flash
JUMP_TABLE do-action-2
  0 | ring
  1 | open
  2 | laugh 
  3 | cry
  default| cry
ram
----
Note that, in the code above, we have omitted the FlashForth response on each line.
This new jump table gives essentially the same behaviour as the first one.
----
\\ Call up the actions.  ok<$,ram>
3 do-action-2 crying ok<$,ram>
0 do-action-2 ring ring ok<$,ram>
2 do-action-2 ha ha ok<$,ram>
5 do-action-2 crying ok<$,ram>
----
Although not evident in this example, `JUMP_TABLE` allows more general key values
than we could use in the basic array implementation for `do-action`.
We could, for example, build a jump table with a selection of character codes as the keys.

= Strings

The _Hello World!_ program, back in the section on the interpreter,
could have been written a little differently, as the following transcript shows.
----
: hey2 s"" Hello, World!"" cr type ;  ok<#,ram>
hey2 
Hello, World! ok<#,ram>
----
The word `s""` compiles the string into Flash memory and, at run time,
leaves the address of the string and the number of characters in the string
on the stack.
Using this information, the word `type` will send the characters to the standard output. 

== Pictured numeric output

// Note the need to escape the # for the word #s

To get numbers output in a particular format, FlashForth provides
the basic words `#`, `<#`, `\\#s`, `#>`, `sign` and `hold`.
These words are intended for use within word definitions.
Here is an example of their use.
----
: (d.2) ( d -- caddr u) 
  tuck dabs <# # # [char] . hold #s rot sign #> ;  ok<#,ram>
----
A double number sits on the stack, with it most significant bits, including its sign, in TOS.
First, `tuck` copies TOS (with the sign bit) to below the double number and 
then the absolute value is converted to a string of characters representing the unsigned
value.
Starting with the least significant digits, there will be two to the right of a decimal point.
The phrase `[char] . hold` adds the decimal point to the string.
In this phrase, `[char] .` builds in the representation of the decimal point 
as a numeric literal
(ASCII code 46) and `hold` then adds it to the string under construction.
After adding the decimal point, the word `\\#s` converts as many remaining digits as required.
The word `rot` is used to bring the copy of the original most-significant cell to TOS
and the word `sign` adds a negative sign to the string if required.
Finally, word `#>` finishes the conversion, 
leaving the character-address of the resultant string 
and the number of characters in it on the top of the stack.
----
437658. (d.2) type 4376.58 ok<#,ram>
-437699. (d.2) type -4376.99 ok<#,ram>
45. (d.2) type 0.45 ok<#,ram>
----
Note that, with FlashForth, double integers must be entered as literal values 
with the decimal point as the last character.


= Forth programming style

There is much written on the style of Forth programming and, indeed, there is book
called ""Thinking Forth"".^<<brodie_2004,2>>^
Here are a number of recurring statements on programming in Forth that are relevant
to sections of this tutorial:

- Build your application from the bottom up, testing new words as you go.
- Choose simple and meaningful names, so that the intent of each word is clear
  and your code is easily read, almost as statements you would make to another person.
- Always provide stack-effect comments.
- As you build your application, refactor your code aggressively so that you
  don't need complicated stack manipulations to access your data.
- Clean up after yourself and don't leave rubbish on the stack.
- Use the return-stack for temporary storage when it makes your code cleaner
  but be very careful to clean up when doing so.


[bibliography]
= References

* [[[brodie_1987,1]]] Brodie, L. and Forth Inc. (1987) Starting Forth: An introduction to the Forth Language and operating system for beginners and professionals, 2nd Ed. _Prentice Hall_  ISBN 0-13-843079-9. Also, updated and online http://home.iae.nl/users/mhx/sf.html and the official online version http://www.forth.com/starting-forth/

* [[[brodie_2004,2]]] Brodie, L. (2004) Thinking Forth: A Language and Philosophy for Solving Problems. _Punchy Publishing_ ISBN 0976458705. Also online http://thinking-forth.sourceforge.net/

* [[[conklin_2007,3]]] Conklin, E. K. and Rather, E. D. (2007) Forth Programmer's Handbook, 3rd Ed. _Forth Inc._ ISBN 1-4196-7549-4

* [[[noble_2001,4]]] Noble, J. V. (2001) A Beginner's Guide to Forth, http://galileo.phys.virginia.edu/classes/551.jvn.fall01/primer.htm

* [[[pelc_2011,5]]] Pelc, S. (2011). Programming Forth. _Microprocessor Engineering Limited_, ISBN 978-0-9525310-5-0.  http://www.mpeforth.com/


",12488,False,2058.76844231901,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::{page-component-version}@camel-spring-boot::page$box-starter.adoc[]
",12330,True,2567.6718674769304,median
"[[scoreCalculation]]
= Score calculation
:doctype: book
:imagesdir: ..
:sectnums:
:toc: left
:icons: font
:experimental:


[[scoreTerminology]]
== Score terminology


[[whatIsAScore]]
=== What is a score?

Every `@PlanningSolution` class has a score.
The score is an objective way to compare two solutions.
The solution with the higher score is better.
The `Solver` aims to find the solution with the highest `Score` of all possible solutions.
The _best solution_ is the solution with the highest `Score` that `Solver` has encountered during solving,
which might be the __optimal solution__.

OptaPlanner cannot automatically know which solution is best for your business,
so you need to tell it how to calculate the score of a given `@PlanningSolution` instance according to your business needs.
If you forget or are unable to implement an important business constraint, the solution is probably useless:

image::ScoreCalculation/optimalWithIncompleteConstraints.png[align=""center""]


[[formalizeTheBusinessConstraints]]
=== Formalize the business constraints

To implement a verbal business constraint, it needs to be formalized as a score constraint.
Luckily, defining constraints in OptaPlanner is very flexible through the following score techniques:

* **Score signum (positive or negative)**: maximize or minimize a constraint type
* **Score weight**: put a cost/profit on a constraint type
* **Score level (hard, soft, ...)**: prioritize a group of constraint types
* *Pareto scoring* (rarely used)

Take the time to acquaint yourself with the first three techniques.
Once you understand them, formalizing most business constraints becomes straightforward.

[NOTE]
====
Do not presume that your business knows all its score constraints in advance.
Expect score constraints to be added, changed or removed after the first releases.
====


[[scoreConstraintSignum]]
=== Score constraint signum (positive or negative)

All score techniques are based on constraints.
A constraint can be a simple pattern (such as __Maximize the apple harvest in the solution__) or a more complex pattern.
A positive constraint is a constraint you want to maximize.
A negative constraint is a constraint you want to minimize

image::ScoreCalculation/positiveAndNegativeConstraints.png[align=""center""]

The image above illustrates that **the optimal solution always has the highest score**,
regardless if the constraints are positive or negative.

Most planning problems have only negative constraints and therefore have a negative score.
In that case, the score is the sum of the weight of the negative constraints being broken, with a perfect score of 0.
For example in n queens, the score is the negative of the number of queen pairs which can attack each other.

Negative and positive constraints can be combined, even in the same score level.

When a constraint activates (because the negative constraint is broken or the positive constraint is fulfilled)
on a certain planning entity set, it is called a __constraint match__.


[[scoreConstraintWeight]]
=== Score constraint weight

Not all score constraints are equally important.
If breaking one constraint is equally bad as breaking another constraint x times,
then those two constraints have a different weight (but they are in the same score level).
For example in vehicle routing, you can make one _unhappy driver_ constraint match count
as much as two _fuel tank usage_ constraint matches:

image::ScoreCalculation/scoreWeighting.png[align=""center""]

Score weighting is easy in use cases where you can __put a price tag on everything__.
In that case, the positive constraints maximize revenue and the negative constraints minimize expenses, so together they maximize profit.
Alternatively, score weighting is also often used to create social <<fairnessScoreConstraints,fairness>>.
For example, a nurse, who requests a free day, pays a higher weight on New Years eve than on a normal day.

The weight of a constraint match can depend on the planning entities involved.
For example in cloud balancing, the weight of the soft constraint match for an active `Computer`
is the maintenance `cost` of that `Computer` (which differs per computer).

Putting a good weight on a constraint is often a difficult analytical decision,
because it is about making choices and trade-offs against other constraints.
Different stakeholders have different priorities.
*Don't waste time with constraint weight discussions at the start of an implementation,
instead add a <<constraintConfiguration, constraint configuration>>
and  allow users to change them through a UI.*
A non-accurate weight is less damaging than mediocre algorithms:

image::ScoreCalculation/scoreTradeoffInPerspective.png[align=""center""]

Most use cases use a `Score` with `int` weights, such as <<hardSoftScore,HardSoftScore>>.


[[scoreLevel]]
=== Score constraint level (hard, soft, ...)

Sometimes a score constraint outranks another score constraint, no matter how many times the latter is broken.
In that case, those score constraints are in different levels.
For example, a nurse cannot do two shifts at the same time (due to the constraints of physical reality),
so this outranks all nurse happiness constraints.

Most use cases have only two score levels, hard and soft.
The levels of two scores are compared lexicographically.
The first score level gets compared first.
If those differ, the remaining score levels are ignored.
For example, a score that breaks `0` hard constraints and `1000000` soft constraints is better
than a score that breaks `1` hard constraint and `0` soft constraints.

image::ScoreCalculation/scoreLevels.png[align=""center""]

If there are two (or more) score levels, for example <<hardSoftScore,HardSoftScore>>,
then a score is _feasible_ if no hard constraints are broken.

[NOTE]
====
By default, OptaPlanner will always assign all planning variables a planning value.
If there is no feasible solution, this means the best solution will be infeasible.
To instead leave some of the planning entities unassigned, apply <<overconstrainedPlanning,overconstrained planning>>.
====

For each constraint, you need to pick a score level, a score weight and a score signum.
For example: `-1soft` which has score level of ``soft``, a weight of `1` and a negative signum.
Do not use a big constraint weight when your business actually wants different score levels.
That hack, known as __score folding__, is broken:

image::ScoreCalculation/scoreFoldingIsBroken.png[align=""center""]


[NOTE]
====
Your business might tell you that your hard constraints all have the same weight, because they cannot be broken (so the weight does not matter). This is not true because if no feasible solution exists for a specific dataset, the least infeasible solution allows the business to estimate how many business resources they are lacking.
For example in cloud balancing, how many new computers to buy.

Furthermore, it will likely create a <<scoreTrap,score trap>>.
For example in cloud balance if a `Computer` has seven CPU too little for its ``Process``es, then it must be weighted seven times as much as if it had only one CPU too little.
====

Three or more score levels are also supported.
For example: a company might decide that profit outranks employee satisfaction (or vice versa),
while both are outranked by the constraints of physical reality.

[NOTE]
====
To model <<fairnessScoreConstraints,fairness or load balancing>>, there is no need to use lots of score levels
(even though OptaPlanner can handle many score levels).
====

Most use cases use a `Score` with two or three weights,
such as <<hardSoftScore,HardSoftScore>> and <<hardMediumSoftScore,HardMediumSoftScore>>.


[[paretoScoring]]
=== Pareto scoring (AKA multi-objective optimization scoring)

Far less common is the use case of pareto optimization, which is also known as _multi-objective optimization_.
In pareto scoring, score constraints are in the same score level, yet they are not weighted against each other.
When two scores are compared, each of the score constraints are compared individually and the score with the most dominating score constraints wins.
Pareto scoring can even be combined with score levels and score constraint weighting.

Consider this example with positive constraints, where we want to get the most apples and oranges.
Since it is impossible to compare apples and oranges, we cannot weigh them against each other.
Yet, despite that we cannot compare them, we can state that two apples are better than one apple.
Similarly, we can state that two apples and one orange are better than just one orange.
So despite our inability to compare some Scores conclusively (at which point we declare them equal), we can find a set of optimal scores.
Those are called pareto optimal.

image::ScoreCalculation/paretoOptimizationScoring.png[align=""center""]

Scores are considered equal far more often.
It is left up to a human to choose the better out of a set of best solutions (with equal scores) found by OptaPlanner.
In the example above, the user must choose between solution A (three apples and one orange) and solution B (one apple and six oranges). It is guaranteed that OptaPlanner has not found another solution which has more apples or more oranges or even a better combination of both (such as two apples and three oranges).

To implement pareto scoring in OptaPlanner, <<customScore,implement a custom `ScoreDefinition` and `Score`>> (and replace the ``BestSolutionRecaller``). Future versions will provide out-of-the-box support.

[NOTE]
====
A pareto ``Score``'s `compareTo` method is not transitive because it does a pareto comparison.
For example: having two apples is greater than one apple.
One apple is equal to One orange.
Yet, two apples are not greater than one orange (but actually equal). Pareto comparison violates the contract of the interface ``java.lang.Comparable``'s `compareTo` method, but Planners systems are __pareto comparison safe__, unless explicitly stated otherwise in this documentation.
====


[[combiningScoreTechniques]]
=== Combining score techniques

All the score techniques mentioned above, can be combined seamlessly:

image::ScoreCalculation/scoreComposition.png[align=""center""]


[[scoreInterface]]
=== `Score` interface

A score is represented by the `Score` interface, which naturally extends ``Comparable``:

[source,java,options=""nowrap""]
----
public interface Score<...> extends Comparable<...> {
    ...
}
----

The `Score` implementation to use depends on your use case.
Your score might not efficiently fit in a single `long` value.
OptaPlanner has several built-in `Score` implementations, but you can implement a custom `Score` too.
Most use cases tend to use the built-in ``HardSoftScore``.

image::ScoreCalculation/scoreClassDiagram.png[align=""center""]

All Score implementations also have an `initScore` (which is an ``int``).It is mostly intended for internal use in OptaPlanner: it is the negative number of uninitialized planning variables.
From a user's perspective this is ``0``, unless a Construction Heuristic is terminated before it could initialize all planning variables (in which case `Score.isSolutionInitialized()` returns ``false``).

The `Score` implementation (for example ``HardSoftScore``) must be the same throughout a `Solver` runtime.
The `Score` implementation is configured in the solution domain class:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class CloudBalance {
    ...

    @PlanningScore
    private HardSoftScore score;

}
----

[[avoidFloatingPointNumbersInScoreCalculation]]
=== Avoid floating point numbers in score calculation

Avoid the use of `float` or `double` in score calculation.
Use `BigDecimal` or scaled `long` instead.

Floating point numbers (``float`` and ``double``) cannot represent a decimal number correctly.
For example: a `double` cannot hold the value `0.05` correctly.
Instead, it holds the nearest representable value.
Arithmetic (including addition and subtraction) with floating point numbers, especially for planning problems, leads to incorrect decisions:

image::ScoreCalculation/scoreWeightType.png[align=""center""]

Additionally, floating point number addition is not associative:

[source,java,options=""nowrap""]
----
System.out.println( ((0.01 + 0.02) + 0.03) == (0.01 + (0.02 + 0.03)) ); // returns false
----

This leads to __score corruption__.

Decimal numbers (``BigDecimal``) have none of these problems.

[NOTE]
====
BigDecimal arithmetic is considerably slower than ``int``, `long` or `double` arithmetic.
In experiments we have seen the score calculation take five times longer.

Therefore, in many cases, it can be worthwhile to multiply _all_ numbers for a single score weight by a plural of ten, so the score weight fits in a scaled `int` or ``long``.
For example, if we multiply all weights by ``1000``, a fuelCost of `0.07` becomes a fuelCostMillis of `70` and no longer uses a decimal score weight.
====


[[scoreType]]
== Choose a score type

Depending on the number of score levels and type of score weights you need, choose a `Score` type.
Most use cases use a ``HardSoftScore``.

[NOTE]
====
To properly write a `Score` to a database (with JPA/Hibernate) or to XML/JSON (with XStream/JAXB/Jackson),
see <<integration,the integration chapter>>.
====


[[simpleScore]]
=== `SimpleScore`

A `SimpleScore` has a single `int` value, for example ``-123``.
It has a single score level.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private SimpleScore score;
----

Variants of this `Score` type:

* `SimpleLongScore` uses a `long` value instead of an `int` value.
* `SimpleBigDecimalScore` uses a `BigDecimal` value instead of an `int` value.


[[hardSoftScore]]
=== `HardSoftScore` (Recommended)

A `HardSoftScore` has a hard `int` value and a soft `int` value, for example ``-123hard/-456soft``.
It has two score levels (hard and soft).

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardSoftScore score;
----

Variants of this `Score` type:

* `HardSoftLongScore` uses `long` values instead of `int` values.
* `HardSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[hardMediumSoftScore]]
=== `HardMediumSoftScore`

A `HardMediumSoftScore` which has a hard `int` value, a medium `int` value and a soft `int` value, for example ``-123hard/-456medium/-789soft``.
It has three score levels (hard, medium and soft).
The hard level determines if the solution is feasible,
and the medium level and soft level score values determine
how well the solution meets business goals.
Higher medium values take precedence over soft values irrespective of the soft value.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardMediumSoftScore score;
----

Variants of this `Score` type:

* `HardMediumSoftLongScore` uses `long` values instead of `int` values.
* `HardMediumSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[bendableScore]]
=== `BendableScore`

A `BendableScore` has a configurable number of score levels.
It has an array of hard `int` values and an array of soft `int` values,
for example with two hard levels and three soft levels, the score can be ``[-123/-456]hard/[-789/-012/-345]soft``.
In that case, it has five score levels.
A solution is feasible if all hard levels are at least zero.

A BendableScore with one hard level and one soft level is equivalent to a HardSoftScore,
while a BendableScore with one hard level and two soft levels is equivalent to a HardMediumSoftScore.

[source,java,options=""nowrap""]
----
    @PlanningScore(bendableHardLevelsSize = 2, bendableSoftLevelsSize = 3)
    private BendableScore score;
----

The number of hard and soft score levels need to be set at compilation time.
It is not flexible to change during solving.

[NOTE]
====
Do not use a `BendableScore` with seven levels just because you have seven constraints.
It is extremely rare to use a different score level for each constraint, because that means one constraint match on soft 0 outweighs even a million constraint matches of soft 1.

Usually, multiple constraints share the same level and are weighted against each other.
Use <<explainingTheScore,explaining the score>> to get the weight of individual constraints in the same level.
====

Variants of this `Score` type:

* `BendableLongScore` uses `long` values instead of `int` values.
* `BendableBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[customScore]]
=== Implementing a custom score

Internally, each `Score` implementation also has a `ScoreDefinition` implementation.
For example: `SimpleScore` is defined by ``SimpleScoreDefinition``.
The `ScoreDefinition` interface defines the score representation.

To implement a custom ``Score``, also implement such a custom ``ScoreDefinition``.
Extend `AbstractScoreDefinition` (preferably by copy pasting ``HardSoftScoreDefinition``) and start from there.
Then hook your custom `ScoreDefinition` in the domain:

[source,java,options=""nowrap""]
----
    @PlanningScore(scoreDefinitionClass = MyCustomScoreDefinition.class)
    private MyCustomScore score;
----

To have it integrate seamlessly with <<jpaAndHibernatePersistingAScore,JPA/Hibernate>>,
<<integrationWithXStream,XStream>>, <<integrationWithJackson,Jackson>>, ...,
you'll need to write custom glue code too.


[[calculateTheScore]]
== Calculate the `Score`


[[scoreCalculationTypes]]
=== Score calculation types

There are several ways to calculate the `Score` of a solution:

* **<<easyJavaScoreCalculation,Easy Java score calculation>>**: Implement all constraints together in a single method in Java (or another JVM language). Does not scale.
* **<<constraintStreams,Constraint streams score calculation>>**: Implement each constraint as a separate ConstraintStream in Java (or another JVM language). Fast and scalable.
* **<<incrementalJavaScoreCalculation,Incremental Java score calculation>>** (not recommended): Implement multiple low-level methods in Java (or another JVM language). Fast and scalable. Very difficult to implement and maintain.
* **<<droolsScoreCalculation,Drools score calculation>>**: Implement each constraint as a separate score rule in DRL. Scalable.

Every score calculation type can work with any Score definition (such as ``HardSoftScore`` or ``HardMediumSoftScore``).
All score calculation types are Object Oriented and can reuse existing Java code.

[IMPORTANT]
====
The score calculation must be read-only.
It must not change the planning entities or the problem facts in any way.
For example, it must not call a setter method on a planning entity in the score calculation.

OptaPlanner does not recalculate the score of a solution if it can predict it (unless an <<environmentMode,environmentMode assertion>> is enabled).
For example, after a winning step is done, there is no need to calculate the score because that move was done and undone earlier.
As a result, there is no guarantee that changes applied during score calculation actually happen.

To update planning entities when the planning variable change, use <<shadowVariable,shadow variables>> instead.
====


[[easyJavaScoreCalculation]]
=== Easy Java score calculation

An easy way to implement your score calculation in Java.

* Advantages:
** Plain old Java: no learning curve
** Opportunity to delegate score calculation to an existing code base or legacy system
* Disadvantages:
** Slower
** Does not scale because there is no <<incrementalScoreCalculation,incremental score calculation>>

Implement the one method of the interface ``EasyScoreCalculator``:

[source,java,options=""nowrap""]
----
public interface EasyScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    Score_ calculateScore(Solution_ solution);

}
----

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensEasyScoreCalculator
    implements EasyScoreCalculator<NQueens, SimpleScore> {

    @Override
    public SimpleScore calculateScore(NQueens nQueens) {
        int n = nQueens.getN();
        List<Queen> queenList = nQueens.getQueenList();

        int score = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                Queen leftQueen = queenList.get(i);
                Queen rightQueen = queenList.get(j);
                if (leftQueen.getRow() != null && rightQueen.getRow() != null) {
                    if (leftQueen.getRowIndex() == rightQueen.getRowIndex()) {
                        score--;
                    }
                    if (leftQueen.getAscendingDiagonalIndex() == rightQueen.getAscendingDiagonalIndex()) {
                        score--;
                    }
                    if (leftQueen.getDescendingDiagonalIndex() == rightQueen.getDescendingDiagonalIndex()) {
                        score--;
                    }
                }
            }
        }
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
  </scoreDirectorFactory>
----

To configure values of an `EasyScoreCalculator` dynamically in the solver configuration
(so the <<benchmarker,Benchmarker>> can tweak those parameters),
add the `easyScoreCalculatorCustomProperties` element and use <<customPropertiesConfiguration,custom properties>>:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>...MyEasyScoreCalculator</easyScoreCalculatorClass>
    <easyScoreCalculatorCustomProperties>
      <property name=""myCacheSize"" value=""1000"" />
    </easyScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[incrementalJavaScoreCalculation]]
=== Incremental Java score calculation

A way to implement your score calculation incrementally in Java.

* Advantages:
** Very fast and scalable
*** Currently the fastest if implemented correctly
* Disadvantages:
** Hard to write
*** A scalable implementation heavily uses maps, indexes, ... (things the Drools rule engine can do for you)
*** You have to learn, design, write and improve all these performance optimizations yourself
** Hard to read
*** Regular score constraint changes can lead to a high maintenance cost

Implement all the methods of the interface `IncrementalScoreCalculator`:

[source,java,options=""nowrap""]
----
public interface IncrementalScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    void resetWorkingSolution(Solution_ workingSolution);

    void beforeEntityAdded(Object entity);

    void afterEntityAdded(Object entity);

    void beforeVariableChanged(Object entity, String variableName);

    void afterVariableChanged(Object entity, String variableName);

    void beforeEntityRemoved(Object entity);

    void afterEntityRemoved(Object entity);

    Score_ calculateScore();

}
----

image::ScoreCalculation/incrementalScoreCalculatorSequenceDiagram.png[align=""center""]

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensAdvancedIncrementalScoreCalculator
    extends IncrementalScoreCalculator<NQueens, SimpleScore> {

    private Map<Integer, List<Queen>> rowIndexMap;
    private Map<Integer, List<Queen>> ascendingDiagonalIndexMap;
    private Map<Integer, List<Queen>> descendingDiagonalIndexMap;

    private int score;

    public void resetWorkingSolution(NQueens nQueens) {
        int n = nQueens.getN();
        rowIndexMap = new HashMap<Integer, List<Queen>>(n);
        ascendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        descendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        for (int i = 0; i < n; i++) {
            rowIndexMap.put(i, new ArrayList<Queen>(n));
            ascendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            descendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            if (i != 0) {
                ascendingDiagonalIndexMap.put(n - 1 + i, new ArrayList<Queen>(n));
                descendingDiagonalIndexMap.put((-i), new ArrayList<Queen>(n));
            }
        }
        score = 0;
        for (Queen queen : nQueens.getQueenList()) {
            insert(queen);
        }
    }

    public void beforeEntityAdded(Object entity) {
        // Do nothing
    }

    public void afterEntityAdded(Object entity) {
        insert((Queen) entity);
    }

    public void beforeVariableChanged(Object entity, String variableName) {
        retract((Queen) entity);
    }

    public void afterVariableChanged(Object entity, String variableName) {
        insert((Queen) entity);
    }

    public void beforeEntityRemoved(Object entity) {
        retract((Queen) entity);
    }

    public void afterEntityRemoved(Object entity) {
        // Do nothing
    }

    private void insert(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            int rowIndex = queen.getRowIndex();
            List<Queen> rowIndexList = rowIndexMap.get(rowIndex);
            score -= rowIndexList.size();
            rowIndexList.add(queen);
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            score -= ascendingDiagonalIndexList.size();
            ascendingDiagonalIndexList.add(queen);
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            score -= descendingDiagonalIndexList.size();
            descendingDiagonalIndexList.add(queen);
        }
    }

    private void retract(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            List<Queen> rowIndexList = rowIndexMap.get(queen.getRowIndex());
            rowIndexList.remove(queen);
            score += rowIndexList.size();
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            ascendingDiagonalIndexList.remove(queen);
            score += ascendingDiagonalIndexList.size();
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            descendingDiagonalIndexList.remove(queen);
            score += descendingDiagonalIndexList.size();
        }
    }

    public SimpleScore calculateScore() {
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in the solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensAdvancedIncrementalScoreCalculator</incrementalScoreCalculatorClass>
  </scoreDirectorFactory>
----

[IMPORTANT]
====
A piece of incremental score calculator code can be difficult to write and to review.
<<invalidScoreDetection,Assert its correctness>> by using an ``EasyScoreCalculator`` to fulfill
the assertions triggered by the ``environmentMode``.
====

To configure values of an `IncrementalScoreCalculator` dynamically in the solver configuration
(so the <<benchmarker,Benchmarker>> can tweak those parameters),
add the `incrementalScoreCalculatorCustomProperties` element and use <<customPropertiesConfiguration,custom properties>>:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>...MyIncrementalScoreCalculator</incrementalScoreCalculatorClass>
    <incrementalScoreCalculatorCustomProperties>
      <property name=""myCacheSize"" value=""1000""/>
    </incrementalScoreCalculatorCustomProperties>
  </scoreDirectorFactory>
----


[[constraintMatchAwareIncrementalScoreCalculator]]
==== `ConstraintMatchAwareIncrementalScoreCalculator`

Optionally, also implement the `ConstraintMatchAwareIncrementalScoreCalculator` interface to:

* Explain a score by splitting it up per score constraint with `ScoreExplanation.getConstraintMatchTotalMap()`.
* Visualize or sort planning entities by how many constraints each one breaks with `ScoreExplanation.getIndictmentMap()`.
* Receive a detailed analysis if the `IncrementalScoreCalculator` is corrupted in `FAST_ASSERT` or `FULL_ASSERT` `environmentMode`,

[source,java,options=""nowrap""]
----
public interface ConstraintMatchAwareIncrementalScoreCalculator<Solution_, Score_ extends Score<Score_>> {

    void resetWorkingSolution(Solution_ workingSolution, boolean constraintMatchEnabled);

    Collection<ConstraintMatchTotal<Score_>> getConstraintMatchTotals();

    Map<Object, Indictment<Score_>> getIndictmentMap();
}
----

For example in machine reassignment, create one `ConstraintMatchTotal` per constraint type and call `addConstraintMatch()` for each constraint match:

[source,java,options=""nowrap""]
----
public class MachineReassignmentIncrementalScoreCalculator
        implements ConstraintMatchAwareIncrementalScoreCalculator<MachineReassignment, HardSoftLongScore> {
    ...

    @Override
    public void resetWorkingSolution(MachineReassignment workingSolution, boolean constraintMatchEnabled) {
        resetWorkingSolution(workingSolution);
        // ignore constraintMatchEnabled, it is always presumed enabled
    }

    @Override
    public Collection<ConstraintMatchTotal<HardSoftLongScore>> getConstraintMatchTotals() {
        ConstraintMatchTotal<HardSoftLongScore> maximumCapacityMatchTotal = new DefaultConstraintMatchTotal<>(CONSTRAINT_PACKAGE,
            ""maximumCapacity"", HardSoftLongScore.ZERO);
        ...
        for (MrMachineScorePart machineScorePart : machineScorePartMap.values()) {
            for (MrMachineCapacityScorePart machineCapacityScorePart : machineScorePart.machineCapacityScorePartList) {
                if (machineCapacityScorePart.maximumAvailable < 0L) {
                    maximumCapacityMatchTotal.addConstraintMatch(
                            Arrays.asList(machineCapacityScorePart.machineCapacity),
                            HardSoftLongScore.valueOf(machineCapacityScorePart.maximumAvailable, 0));
                }
            }
        }
        ...
        List<ConstraintMatchTotal<HardSoftLongScore>> constraintMatchTotalList = new ArrayList<>(4);
        constraintMatchTotalList.add(maximumCapacityMatchTotal);
        ...
        return constraintMatchTotalList;
    }

    @Override
    public Map<Object, Indictment<HardSoftLongScore>> getIndictmentMap() {
        return null; // Calculate it non-incrementally from getConstraintMatchTotals()
    }
}
----

That `getConstraintMatchTotals()` code often duplicates some of the logic of the normal `IncrementalScoreCalculator` methods.
Constraint Streams and Drools Score Calculation don't have this disadvantage, because they are constraint match aware automatically when needed,
without any extra domain-specific code.


[[initializingScoreTrend]]
=== `InitializingScoreTrend`

The `InitializingScoreTrend` specifies how the Score will change as more and more variables are initialized (while the already initialized variables do not change). Some optimization algorithms (such Construction Heuristics and Exhaustive Search) run faster if they have such information.

For the Score (or each <<scoreLevel,score level>> separately), specify a trend:

* `ANY` (default): Initializing an extra variable can change the score positively or negatively. Gives no performance gain.
* `ONLY_UP` (rare): Initializing an extra variable can only change the score positively. Implies that:
** There are only positive constraints
** And initializing the next variable cannot unmatch a positive constraint that was matched by a previous initialized variable.
* ``ONLY_DOWN``: Initializing an extra variable can only change the score negatively. Implies that:
** There are only negative constraints
** And initializing the next variable cannot unmatch a negative constraint that was matched by a previous initialized variable.

Most use cases only have negative constraints.
Many of those have an `InitializingScoreTrend` that only goes down:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>.../cloudBalancingConstraints.drl</scoreDrl>
    <initializingScoreTrend>ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----

Alternatively, you can also specify the trend for each score level separately:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>.../cloudBalancingConstraints.drl</scoreDrl>
    <initializingScoreTrend>ONLY_DOWN/ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----


[[invalidScoreDetection]]
=== Invalid score detection

When you put the <<environmentMode,`environmentMode`>> in `FULL_ASSERT` (or ``FAST_ASSERT``),
it will detect score corruption in the <<incrementalScoreCalculation,incremental score calculation>>.
However, that will not verify that your score calculator actually implements your score constraints as your business desires.
For example, one constraint might consistently match the wrong pattern.
To verify the constraints against an independent implementation, configure a ``assertionScoreDirectorFactory``:

[source,xml,options=""nowrap""]
----
  <environmentMode>FAST_ASSERT</environmentMode>
  ...
  <scoreDirectorFactory>
    <constraintProviderClass>org.optaplanner.examples.nqueens.optional.score.NQueensConstraintProviderorg.optaplanner.examples.nqueens.optional.score.NQueensConstraintProvider</constraintProviderClass>
    <assertionScoreDirectorFactory>
      <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.optional.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
    </assertionScoreDirectorFactory>
  </scoreDirectorFactory>
----

This way, the `NQueensConstraintProvider` implementation is validated by the ``EasyScoreCalculator``.

[NOTE]
====
This works well to isolate score corruption,
but to verify that the constraint implement the real business needs,
<<constraintStreamsTesting, a unit test with a ConstraintVerifier>> is usually better.
====


[[scoreCalculationPerformanceTricks]]
== Score calculation performance tricks


[[scoreCalculationPerformanceTricksOverview]]
=== Overview

The `Solver` will normally spend most of its execution time running the score calculation
(which is called in its deepest loops).
Faster score calculation will return the same solution in less time with the same algorithm,
which normally means a better solution in equal time.


[[scoreCalculationSpeed]]
=== Score calculation speed

After solving a problem, the `Solver` will log the __score calculation speed per second__.
This is a good measurement of Score calculation performance,
despite that it is affected by non score calculation execution time.
It depends on the problem scale of the problem dataset.
Normally, even for high scale problems, it is higher than ``1000``, except if you are using an ``EasyScoreCalculator``.

[IMPORTANT]
====
When improving your score calculation, focus on maximizing the score calculation speed, instead of maximizing the best score.
A big improvement in score calculation can sometimes yield little or no best score improvement, for example when the algorithm is stuck in a local or global optima.
If you are watching the calculation speed instead, score calculation improvements are far more visible.

Furthermore, watching the calculation speed allows you to remove or add score constraints,
and still compare it with the original's calculation speed.
Comparing the best score with the original's best score is pointless: it's comparing apples and oranges.
====


[[incrementalScoreCalculation]]
=== Incremental score calculation (with deltas)

When a solution changes, incremental score calculation (AKA delta based score calculation)
calculates the delta with the previous state to find the new ``Score``,
instead of recalculating the entire score on every solution evaluation.

For example, when a single queen A moves from row `1` to ``2``,
it will not bother to check if queen B and C can attack each other, since neither of them changed:

image::ScoreCalculation/incrementalScoreCalculationNQueens04.png[align=""center""]

Similarly in employee rostering:

image::ScoreCalculation/incrementalScoreCalculationEmployeeRostering.png[align=""center""]

This is a huge performance and scalability gain.
*Drools score calculation gives you this huge scalability gain without forcing you to write a complicated incremental score calculation algorithm.*
Just let the Drools rule engine do the hard work.

Notice that the speedup is relative to the size of your planning problem (your __n__), making incremental score calculation far more scalable.


[[avoidCallingRemoteServicesDuringScoreCalculation]]
=== Avoid calling remote services during score calculation

Do not call remote services in your score calculation (except if you are bridging `EasyScoreCalculator` to a legacy system). The network latency will kill your score calculation performance.
Cache the results of those remote services if possible.

If some parts of a constraint can be calculated once, when the `Solver` starts, and never change during solving,
then turn them into <<cachedProblemFact,cached problem facts>>.


[[pointlessConstraints]]
=== Pointless constraints

If you know a certain constraint can never be broken (or it is always broken), do not write a score constraint for it.
For example in n queens, the score calculation does not check if multiple queens occupy the same column,
because a ``Queen``'s `column` never changes and every solution starts with each `Queen` on a different ``column``.

[NOTE]
====
Do not go overboard with this.
If some datasets do not use a specific constraint but others do, just return out of the constraint as soon as you can.
There is no need to dynamically change your score calculation based on the dataset.
====


[[buildInHardConstraint]]
=== Built-in hard constraint

Instead of implementing a hard constraint, it can sometimes be built in.
For example, if `Lecture` A should never be assigned to `Room` X, but it uses `ValueRangeProvider` on Solution,
so the `Solver` will often try to assign it to `Room` X too (only to find out that it breaks a hard constraint).
Use <<valueRangeProviderOnPlanningEntity,a ValueRangeProvider on the planning entity>> or <<filteredSelection,filtered selection>> to define that Course A should only be assigned a `Room` different than X.

This can give a good performance gain in some use cases, not just because the score calculation is faster,
but mainly because most optimization algorithms will spend less time evaluating infeasible solutions.
However, usually this is not a good idea because there is a real risk of trading short term benefits for long term harm:

* Many optimization algorithms rely on the freedom to break hard constraints when changing planning entities,
to get out of local optima.
* Both implementation approaches have limitations (feature compatibility, disabling automatic performance optimizations),
as explained in their documentation.


[[otherScoreCalculationPerformanceTricks]]
=== Other score calculation performance tricks

* Verify that your score calculation happens in the correct `Number` type.
If you are making the sum of `int` values, do not let Drools sum it in a `double` which takes longer.
* For optimal performance, always use server mode (``java -server``).
We have seen performance increases of 50% by turning on server mode.
* For optimal performance, use the latest Java version.
For example, in the past we have seen performance increases of 30% by switching from java 1.5 to 1.6.
* Always remember that premature optimization is the root of all evil.
Make sure your design is flexible enough to allow configuration based tweaking.


[[scoreTrap]]
=== Score trap

Make sure that none of your score constraints cause a score trap.
A trapped score constraint uses the same weight for different constraint matches, when it could just as easily use a different weight.
It effectively lumps its constraint matches together, which creates a flatlined score function for that constraint.
This can cause a solution state in which several moves need to be done to resolve or lower the weight of that single constraint.
Some examples of score traps:

* You need two doctors at each table, but you are only moving one doctor at a time. So the solver has no incentive to move a doctor to a table with no doctors. Punish a table with no doctors more than a table with only one doctor in that score constraint in the score function.
* Two exams need to be conducted at the same time, but you are only moving one exam at a time. So the solver has to move one of those exams to another timeslot without moving the other in the same move. Add a coarse-grained move that moves both exams at the same time.

For example, consider this score trap.
If the blue item moves from an overloaded computer to an empty computer, the hard score should improve.
The trapped score implementation fails to do that:

image::ScoreCalculation/scoreTrap.png[align=""center""]

The Solver should eventually get out of this trap, but it will take a lot of effort (especially if there are even more processes on the overloaded computer). Before they do that, they might actually start moving more processes into that overloaded computer, as there is no penalty for doing so.

[NOTE]
====
Avoiding score traps does not mean that your score function should be smart enough to avoid local optima.
Leave it to the optimization algorithms to deal with the local optima.

Avoiding score traps means to avoid, for each score constraint individually, a flatlined score function.
====

[IMPORTANT]
====
Always specify the degree of infeasibility.
The business will often say ""if the solution is infeasible, it does not matter how infeasible it is."" While that is true for the business, it is not true for score calculation as it benefits from knowing how infeasible it is.
In practice, soft constraints usually do this naturally and it is just a matter of doing it for the hard constraints too.
====

There are several ways to deal with a score trap:

* Improve the score constraint to make a distinction in the score weight. For example, penalize `-1hard` for every missing CPU, instead of just `-1hard` if any CPU is missing.
* If changing the score constraint is not allowed from the business perspective, add a lower score level with a score constraint that makes such a distinction. For example, penalize `-1subsoft` for every missing CPU, on top of `-1hard` if any CPU is missing. The business ignores the subsoft score level.
* Add coarse-grained moves and union select them with the existing fine-grained moves. A coarse-grained move effectively does multiple moves to directly get out of a score trap with a single move. For example, move multiple items from the same container to another container.


[[stepLimitBenchmark]]
=== `stepLimit` benchmark

Not all score constraints have the same performance cost.
Sometimes one score constraint can kill the score calculation performance outright.
Use the <<benchmarker,Benchmarker>> to do a one minute run and check what happens to the score calculation speed if you comment out all but one of the score constraints.


[[fairnessScoreConstraints]]
=== Fairness score constraints

Some use cases have a business requirement to provide a fair schedule (usually as a soft score constraint), for example:

* Fairly distribute the workload amongst the employees, to avoid envy.
* Evenly distribute the workload amongst assets, to improve reliability.

Implementing such a constraint can seem difficult (especially because there are different ways to formalize fairness), but usually the _squared workload_ implementation behaves most desirable.
For each employee/asset, count the workload `w` and subtract `w²` from the score.

image::ScoreCalculation/fairnessScoreConstraint.png[align=""center""]

As shown above, the _squared workload_ implementation guarantees that if you select two employees from a given solution and make their distribution between those two employees fairer, then the resulting new solution will have a better overall score.
Do not just use the difference from the average workload, as that can lead to unfairness, as demonstrated below.

image::ScoreCalculation/fairnessScoreConstraintPitfall.png[align=""center""]


[NOTE]
====
Instead of the __squared workload__, it is also possible to use the https://en.wikipedia.org/wiki/Variance[variance]
(squared difference to the average) or the http://en.wikipedia.org/wiki/Standard_deviation[standard deviation]
(square root of the variance).
This has no effect on the score comparison, because the average will not change during planning.
It is just more work to implement (because the average needs to be known) and trivially slower (because the calculation is a bit longer).
====

When the workload is perfectly balanced, the user often likes to see a `0` score, instead of the distracting `-34soft` in the image above (for the last solution which is almost perfectly balanced).
To nullify this, either add the average multiplied by the number of entities to the score or instead show the variance or standard deviation in the UI.

[[constraintConfiguration]]
== Constraint configuration: adjust constraint weights dynamically

Deciding the correct <<scoreConstraintWeight,weight>> and <<scoreLevel,level>> for each constraint is not easy.
It often involves negotiating with different stakeholders and their priorities.
Furthermore, quantifying the impact of soft constraints is often a new experience for business managers, so they 'll need a number of iterations to get it right.

Don't get stuck between a rock and a hard place.
Provide a UI to adjust the constraint weights and visualize the resulting solution, so the business managers can tweak the constraint weights themselves:

image::ScoreCalculation/parameterizeTheScoreWeights.png[align=""center""]

[[createAConstraintConfiguration]]
=== Create a constraint configuration

First, create a new class to hold the constraint weights and other constraint parameters.
Annotate it with `@ConstraintConfiguration`:

[source,java,options=""nowrap""]
----
@ConstraintConfiguration
public class ConferenceConstraintConfiguration {
    ...
}
----

There will be exactly one instance of this class per planning solution.
The planning solution and the constraint configuration have a one to one relationship,
but they serve a different purpose, so they aren't merged into a single class.
A `@ConstraintConfiguration` class can extend a parent `@ConstraintConfiguration` class,
which can be useful in international use cases with many regional constraints.

Add the constraint configuration on the planning solution
and annotate that field or property with `@ConstraintConfigurationProvider`:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class ConferenceSolution {

    @ConstraintConfigurationProvider
    private ConferenceConstraintConfiguration constraintConfiguration;

    ...
}
----

The `@ConstraintConfigurationProvider` annotation automatically exposes the constraint configuration
as a <<problemFacts,problem fact>>, there is no need to add a `@ProblemFactProperty` annotation.

The constraint configuration class holds the <<constraintWeight, constraint weights>>,
but it can also hold constraint parameters.
For example in conference scheduling, the minimum pause constraint has a constraint weight (like any other constraint),
but it also has a constraint parameter that defines the length of the minimum pause between two talks of the same speaker.
That pause length depends on the conference (= the planning problem):
in some big conferences 20 minutes isn't enough to go from one room to the other.
That pause length is a field in the constraint configuration without a `@ConstraintWeight` annotation.


[[constraintWeight]]
=== Add a constraint weight for each constraint

In the constraint configuration class, add a `@ConstraintWeight` field or property for each constraint:

[source,java,options=""nowrap""]
----
@ConstraintConfiguration(constraintPackage = ""...conferencescheduling.solver"")
public class ConferenceConstraintConfiguration {

    @ConstraintWeight(""Speaker conflict"")
    private HardMediumSoftScore speakerConflict = HardMediumSoftScore.ofHard(10);

    @ConstraintWeight(""Theme track conflict"")
    private HardMediumSoftScore themeTrackConflict = HardMediumSoftScore.ofSoft(10);
    @ConstraintWeight(""Content conflict"")
    private HardMediumSoftScore contentConflict = HardMediumSoftScore.ofSoft(100);

    ...
}
----

The type of the constraint weights must be the same score class as <<scoreOfASolution,the planning solution's score member>>.
For example in conference scheduling, `ConferenceSolution.getScore()` and `ConferenceConstraintConfiguration.getSpeakerConflict()`
both return a `HardMediumSoftScore`.

A constraint weight cannot be null.
Give each constraint weight a default value, but expose them in a UI so the business users can tweak them.
The example above uses the `ofHard()`, `ofMedium()` and `ofSoft()` methods to do that.
Notice how it defaults the _content conflict_ constraint as ten times more important than the _theme track conflict_ constraint.
Normally, a constraint weight only uses one score level,
but it's possible to use multiple score levels (at a small performance cost).

Each constraint has a constraint package and a constraint name, together they form the constraint id.
These connect the constraint weight with the constraint implementation.
*For each constraint weight, there must be a constraint implementation with the same package and the same name.*

* The `@ConstraintConfiguration` annotation has a `constraintPackage` property that defaults to the package of the constraint configuration class.
Most cases with <<droolsScoreCalculation,Drools score calculation>>, need to override that because the DRLs use another package.
For example, the DRL below uses the package `...conferencescheduling.solver`,
so the constraint configuration above specifies a `constraintPackage`.
Cases with <<constraintStreams,Constraint streams>>, normally don't need to specify it.

* The `@ConstraintWeight` annotation has a `value` which is the constraint name (for example ""Speaker conflict"").
It inherits the constraint package from the `@ConstraintConfiguration`,
but it can override that, for example `@ConstraintWeight(constraintPackage = ""...region.france"", ...)`
to use a different constraint package than some of the other weights.

So every constraint weight ends up with a constraint package and a constraint name.
Each constraint weight links with a constraint implementation,
for example in <<droolsScoreCalculation,Drools score calculation>>:

[source,options=""nowrap""]
----
package ...conferencescheduling.solver;

rule ""Speaker conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext);
end

rule ""Theme track conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext, ...);
end

rule ""Content conflict""
    when
        ...
    then
        scoreHolder.penalize(kcontext, ...);
end
----

Each of the constraint weights defines the score level and score weight of their constraint.
The constraint implementation calls `reward()` or `penalize()` and the constraint weight is automatically applied.

If the constraint implementation provides a match weight, that *match weight is multiplied with the constraint weight*.
For example, the _content conflict_ constraint weight defaults to `100soft`
and the constraint implementation penalizes each match based on the number of shared content tags:

[source,java,options=""nowrap""]
----
    @ConstraintWeight(""Content conflict"")
    private HardMediumSoftScore contentConflict = HardMediumSoftScore.ofSoft(100);
----

[source,options=""nowrap""]
----
rule ""Content conflict""
    when
        $talk1 : Talk(...)
        $talk2 : Talk(...)
    then
        scoreHolder.penalize(kcontext,
                $talk2.overlappingContentCount($talk1));
end
----

So when 2 overlapping talks share only 1 content tag, the score is impacted by `-100soft`.
But when 2 overlapping talks share 3 content tags, the match weight is `3`, so the score is impacted by `-300soft`.

[[explainingTheScore]]
== Explaining the score: which constraints are broken?

The easiest way to explain the score during development is to print the return value of `explainScore()`, but only use that method for diagnostic purposes:

[source,java,options=""nowrap""]
----
System.out.println(scoreManager.explainScore(solution));
----

For example in conference scheduling, this prints that talk `S51` is responsible for breaking the hard constraint `Speaker required room tag`:

----
Explanation of score (-1hard/-806soft):
    Constraint match totals:
        -1hard: constraint (Speaker required room tag) has 1 matches:
            -1hard: justifications ([S51])
        -340soft: constraint (Theme track conflict) has 32 matches:
            -20soft: justifications ([S68, S66])
            -20soft: justifications ([S61, S44])
            ...
        ...
    Indictments (top 5 of 72):
        -1hard/-22soft: justification (S51) has 12 matches:
            -1hard: constraint (Speaker required room tag)
            -10soft: constraint (Theme track conflict)
            ...
        ...
----

[IMPORTANT]
====
Do not attempt to parse this string or use it in your UI or exposed services.
Instead use the ConstraintMatch API below and do it properly.
====

[[usingScoreCalculationOutsideTheSolver]]
=== Using score calculation outside the `Solver`

If other parts of your application, for example your webUI, need to calculate the score of a solution, use the `ScoreManager` API:

[source,java,options=""nowrap""]
----
ScoreManager<CloudBalance, HardSoftScore> scoreManager = ScoreManager.create(solverFactory);
ScoreExplanation<CloudBalance, HardSoftScore> scoreExplanation = scoreManager.explain(cloudBalance);
----

Then use it when you need to calculate the `Score` of a solution:

[source,java,options=""nowrap""]
----
HardSoftScore score = scoreExplanation.getScore();
----

Furthermore, the `ScoreExplanation` can help explain the score through constraint match totals and/or indictments:

image::ScoreCalculation/scoreVisualization.png[align=""center""]

[[constraintMatchTotal]]
=== Constraint match total: break down the score by constraint

To break down the score per constraint, get the ``ConstraintMatchTotal``s from the ``ScoreExplanation``:

[source,java,options=""nowrap""]
----
Collection<ConstraintMatchTotal<HardSoftScore>> constraintMatchTotals = scoreExplanation.getConstraintMatchTotalMap().values();
for (ConstraintMatchTotal<HardSoftScore> constraintMatchTotal : constraintMatchTotals) {
    String constraintName = constraintMatchTotal.getConstraintName();
    // The score impact of that constraint
    HardSoftScore totalScore = constraintMatchTotal.getScore();

    for (ConstraintMatch<HardSoftScore> constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
        List<Object> justificationList = constraintMatch.getJustificationList();
        HardSoftScore score = constraintMatch.getScore();
        ...
    }
}
----

Each `ConstraintMatchTotal` represents one constraint and has a part of the overall score.
The sum of all the `ConstraintMatchTotal.getScore()` equals the overall score.

[NOTE]
====
<<constraintStreams,Constraint streams>> and <<droolsScoreCalculation,Drools score calculation>> supports constraint matches automatically, but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
<<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
====

[[indictmentHeatMap]]
=== Indictment heat map: visualize the hot planning entities

To show a heat map in the UI that highlights the planning entities and problem facts have an impact on the ``Score``, get the `Indictment` map from the ``ScoreExplanation``:

[source,java,options=""nowrap""]
----
Map<Object, Indictment<HardSoftScore>> indictmentMap = scoreExplanation.getIndictmentMap();
for (CloudProcess process : cloudBalance.getProcessList()) {
    Indictment<HardSoftScore> indictment = indictmentMap.get(process);
    if (indictment == null) {
        continue;
    }
    // The score impact of that planning entity
    HardSoftScore totalScore = indictment.getScore();

    for (ConstraintMatch<HardSoftScore> constraintMatch : indictment.getConstraintMatchSet()) {
        String constraintName = constraintMatch.getConstraintName();
        HardSoftScore score = constraintMatch.getScore();
        ...
    }
}
----

Each `Indictment` is the sum of all constraints where that justification object is involved with.
The sum of all the `Indictment.getScoreTotal()` differs from the overall score, because multiple ``Indictment``s can share the same `ConstraintMatch`.

[NOTE]
====
<<constraintStreams,Constraint streams>> and <<droolsScoreCalculation,Drools score calculation>> supports constraint matches automatically, but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires
<<constraintMatchAwareIncrementalScoreCalculator,implementing an extra interface>>.
====


[[testingScoreConstraints]]
== Testing score constraints

It's recommended to write a unit test for each score constraint individually to check that it behaves correctly.
Different score calculation types come with different tools for testing.
For more, see <<constraintStreamsTesting,testing constraint streams>> or
<<testingDroolsConstraints,testing Drools constraints>>.
",12068,False,2099.95966977365,median
"// Copyright 2018 The Amber Authors.
//
// Licensed under the Apache License, Version 2.0 (the ""License"");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include ""src/dawn/engine_dawn.h""

#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <iostream>
#include <limits>
#include <string>
#include <utility>
#include <vector>

#include ""amber/amber_dawn.h""
#include ""dawn/dawncpp.h""
#include ""src/dawn/pipeline_info.h""
#include ""src/format.h""
#include ""src/make_unique.h""
#include ""src/sleep.h""

namespace amber {
namespace dawn {

namespace {

// The minimum multiple row pitch observed on Dawn on Metal.  Increase this
// as needed for other Dawn backends.
static const uint32_t kMinimumImageRowPitch = 256;
static const float kLodMin = 0.0;
static const float kLodMax = 1000.0;
static const uint32_t kMaxColorAttachments = 4u;
static const uint32_t kMaxVertexInputs = 16u;
static const uint32_t kMaxVertexAttributes = 16u;
static const uint32_t kMaxDawnBindGroup = 4u;

// A DS for creating and setting the defaults for VertexInputDescriptor
// Copied from Dawn utils source code.
struct ComboVertexInputDescriptor {
  ComboVertexInputDescriptor() {
    ::dawn::VertexInputDescriptor* descriptor =
        reinterpret_cast<::dawn::VertexInputDescriptor*>(this);

    descriptor->indexFormat = ::dawn::IndexFormat::Uint32;
    descriptor->bufferCount = 0;
    descriptor->nextInChain = nullptr;

    // Fill the default values for vertexBuffers and vertexAttributes in
    // buffers.
    ::dawn::VertexAttributeDescriptor vertexAttribute;
    vertexAttribute.shaderLocation = 0;
    vertexAttribute.offset = 0;
    vertexAttribute.format = ::dawn::VertexFormat::Float;
    for (uint32_t i = 0; i < kMaxVertexAttributes; ++i) {
      cAttributes[i] = vertexAttribute;
    }
    for (uint32_t i = 0; i < kMaxVertexBuffers; ++i) {
      cBuffers[i].stride = 0;
      cBuffers[i].stepMode = ::dawn::InputStepMode::Vertex;
      cBuffers[i].attributeCount = 0;
      cBuffers[i].attributes = nullptr;
    }
    // cBuffers[i].attributes points to somewhere in cAttributes.
    // cBuffers[0].attributes points to &cAttributes[0] by default. Assuming
    // cBuffers[0] has two attributes, then cBuffers[1].attributes should
    // point to &cAttributes[2]. Likewise, if cBuffers[1] has 3 attributes,
    // then cBuffers[2].attributes should point to &cAttributes[5].

    // In amber-dawn, the vertex input descriptor is always created assuming
    // these relationships are one to one i.e. cBuffers[i].attributes is always
    // pointing to &cAttributes[i] and cBuffers[i].attributeCount == 1
    cBuffers[0].attributes = &cAttributes[0];
    descriptor->buffers = &cBuffers[0];
  }

  static const uint32_t kMaxVertexBuffers = 16u;
  static const uint32_t kMaxVertexBufferStride = 2048u;
  const void* nextInChain = nullptr;
  ::dawn::IndexFormat indexFormat;
  uint32_t bufferCount;
  ::dawn::VertexBufferDescriptor const* buffers;

  std::array<::dawn::VertexBufferDescriptor, kMaxVertexBuffers> cBuffers;
  std::array<::dawn::VertexAttributeDescriptor, kMaxVertexAttributes>
      cAttributes;
};

// This structure is a container for a few variables that are created during
// CreateRenderPipelineDescriptor and CreateRenderPassDescriptor and we want to
// make sure they don't go out of scope before we are done with them
struct DawnPipelineHelper {
  Result CreateRenderPipelineDescriptor(
      const RenderPipelineInfo& render_pipeline,
      const ::dawn::Device& device,
      const bool ignore_vertex_and_Index_buffers,
      const PipelineData* pipeline_data);
  Result CreateRenderPassDescriptor(
      const RenderPipelineInfo& render_pipeline,
      const ::dawn::Device& device,
      const std::vector<::dawn::TextureView>& texture_view,
      const ::dawn::LoadOp load_op);
  ::dawn::RenderPipelineDescriptor renderPipelineDescriptor;
  ::dawn::RenderPassDescriptor renderPassDescriptor;

  ComboVertexInputDescriptor vertexInputDescriptor;
  ::dawn::RasterizationStateDescriptor rasterizationState;

 private:
  ::dawn::PipelineStageDescriptor fragmentStage;
  ::dawn::PipelineStageDescriptor vertexStage;
  ::dawn::RenderPassColorAttachmentDescriptor*
      colorAttachmentsInfoPtr[kMaxColorAttachments];
  ::dawn::RenderPassDepthStencilAttachmentDescriptor depthStencilAttachmentInfo;
  std::array<::dawn::ColorStateDescriptor*, kMaxColorAttachments> colorStates;
  ::dawn::DepthStencilStateDescriptor depthStencilState;
  ::dawn::ColorStateDescriptor colorStatesDescriptor[kMaxColorAttachments];
  ::dawn::ColorStateDescriptor colorStateDescriptor;
  ::dawn::StencilStateFaceDescriptor stencil_front;
  ::dawn::StencilStateFaceDescriptor stencil_back;
  ::dawn::BlendDescriptor alpha_blend;
  ::dawn::BlendDescriptor color_blend;
  std::string vertexEntryPoint;
  std::string fragmentEntryPoint;
  std::array<::dawn::RenderPassColorAttachmentDescriptor, kMaxColorAttachments>
      colorAttachmentsInfo;
  ::dawn::TextureDescriptor depthStencilDescriptor;
  ::dawn::Texture depthStencilTexture;
  ::dawn::TextureView depthStencilView;
};

// Creates a device-side texture, and returns it through |result_ptr|.
// Assumes the device exists and is valid.  Assumes result_ptr is not null.
// Returns a result code.
Result MakeTexture(const ::dawn::Device& device,
                   ::dawn::TextureFormat format,
                   uint32_t width,
                   uint32_t height,
                   ::dawn::Texture* result_ptr) {
  assert(device);
  assert(result_ptr);
  assert(width * height > 0);
  ::dawn::TextureDescriptor descriptor;
  descriptor.dimension = ::dawn::TextureDimension::e2D;
  descriptor.size.width = width;
  descriptor.size.height = height;
  descriptor.size.depth = 1;
  descriptor.arrayLayerCount = 1;
  descriptor.format = format;
  descriptor.mipLevelCount = 1;
  descriptor.sampleCount = 1;
  descriptor.usage =
      ::dawn::TextureUsage::CopySrc | ::dawn::TextureUsage::OutputAttachment;
  // TODO(dneto): Get a better message by using the Dawn error callback.
  *result_ptr = device.CreateTexture(&descriptor);
  if (*result_ptr)
    return {};
  return Result(""Dawn: Failed to allocate a framebuffer texture"");
}

// Creates a device-side texture, and returns it through |result_ptr|.
// Assumes the device exists and is valid.  Assumes result_ptr is not null.
// Returns a result code.
::dawn::Texture MakeDawnTexture(const ::dawn::Device& device,
                                ::dawn::TextureFormat format,
                                uint32_t width,
                                uint32_t height) {
  assert(device);
  assert(width * height > 0);
  ::dawn::TextureDescriptor descriptor;
  descriptor.dimension = ::dawn::TextureDimension::e2D;
  descriptor.size.width = width;
  descriptor.size.height = height;
  descriptor.size.depth = 1;
  descriptor.arrayLayerCount = 1;
  descriptor.format = format;
  descriptor.mipLevelCount = 1;
  descriptor.sampleCount = 1;
  descriptor.usage =
      ::dawn::TextureUsage::CopySrc | ::dawn::TextureUsage::OutputAttachment;

  return device.CreateTexture(&descriptor);
}

// Result status object and data pointer resulting from a buffer mapping.
struct MapResult {
  Result result;
  const void* data = nullptr;
  uint64_t dataLength = 0;
};

// Handles the update from an asynchronous buffer map request, updating the
// state of the MapResult object hidden inside the |userdata| parameter.
// On a successful mapping outcome, set the data pointer in the map result.
// Otherwise set the map result object to an error, and the data member is
// not changed.
void HandleBufferMapCallback(DawnBufferMapAsyncStatus status,
                             const void* data,
                             uint64_t dataLength,
                             void* userdata) {
  MapResult& map_result = *reinterpret_cast<MapResult*>(userdata);
  switch (status) {
    case DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS:
      map_result.data = data;
      map_result.dataLength = dataLength;
      break;
    case DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR:
      map_result.result = Result(""Buffer map for reading failed: error"");
      break;
    case DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN:
    case DAWN_BUFFER_MAP_ASYNC_STATUS_FORCE32:
      map_result.result = Result(""Buffer map for reading failed: unknown"");
      break;
    case DAWN_BUFFER_MAP_ASYNC_STATUS_DEVICE_LOST:
      map_result.result = Result(""Buffer map for reading failed: device lost"");
      break;
  }
}

// Returns |value| but rounded up to a multiple of |alignment|. |alignment| is
// assumed to be a power of 2.
uint32_t Align(uint32_t value, size_t alignment) {
  assert(alignment <= std::numeric_limits<uint32_t>::max());
  assert(alignment != 0);
  uint32_t alignment32 = static_cast<uint32_t>(alignment);
  return (value + (alignment32 - 1)) & ~(alignment32 - 1);
}

}  // namespace

// Maps the given buffer.  Assumes the buffer has usage bit
// ::dawn::BufferUsage::MapRead set.  Returns a MapResult structure, with
// the status saved in the |result| member and the host pointer to the mapped
// data in the |data| member. Mapping a buffer can fail if the context is
// lost, for example. In the failure case, the |data| member will be null.
MapResult MapBuffer(const ::dawn::Device& device, const ::dawn::Buffer& buf) {
  MapResult map_result;

  buf.MapReadAsync(
      HandleBufferMapCallback,
      reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(&map_result)));
  device.Tick();
  // Wait until the callback has been processed.  Use an exponential backoff
  // interval, but cap it at one second intervals.  But never loop forever.
  const int max_iters = 100;
  const int one_second_in_us = 1000000;
  for (int iters = 0, interval = 1;
       !map_result.data && map_result.result.IsSuccess();
       iters++, interval = std::min(2 * interval, one_second_in_us)) {
    device.Tick();
    if (iters > max_iters) {
      map_result.result = Result(""MapBuffer timed out after 100 iterations"");
      break;
    }
    USleep(uint32_t(interval));
  }
  return map_result;
}

// Creates and returns a dawn BufferCopyView
// Copied from Dawn utils source code.
::dawn::BufferCopyView CreateBufferCopyView(::dawn::Buffer buffer,
                                            uint64_t offset,
                                            uint32_t rowPitch,
                                            uint32_t imageHeight) {
  ::dawn::BufferCopyView bufferCopyView;
  bufferCopyView.buffer = buffer;
  bufferCopyView.offset = offset;
  bufferCopyView.rowPitch = rowPitch;
  bufferCopyView.imageHeight = imageHeight;

  return bufferCopyView;
}

// Creates and returns a dawn TextureCopyView
// Copied from Dawn utils source code.
::dawn::TextureCopyView CreateTextureCopyView(::dawn::Texture texture,
                                              uint32_t mipLevel,
                                              uint32_t arrayLayer,
                                              ::dawn::Origin3D origin) {
  ::dawn::TextureCopyView textureCopyView;
  textureCopyView.texture = texture;
  textureCopyView.mipLevel = mipLevel;
  textureCopyView.arrayLayer = arrayLayer;
  textureCopyView.origin = origin;

  return textureCopyView;
}

Result EngineDawn::MapDeviceTextureToHostBuffer(
    const RenderPipelineInfo& render_pipeline,
    const ::dawn::Device& device) {
  const auto width = render_pipeline.pipeline->GetFramebufferWidth();
  const auto height = render_pipeline.pipeline->GetFramebufferHeight();

  const auto pixelSize = render_pipeline.pipeline->GetColorAttachments()[0]
                             .buffer->GetElementStride();
  const auto dawn_row_pitch = Align(width * pixelSize, kMinimumImageRowPitch);
  const auto size = height * dawn_row_pitch;
  // Create a temporary buffer to hold the color attachment content and can
  // be mapped
  ::dawn::BufferDescriptor descriptor;
  descriptor.size = size;
  descriptor.usage =
      ::dawn::BufferUsage::CopyDst | ::dawn::BufferUsage::MapRead;
  ::dawn::Buffer copy_buffer = device.CreateBuffer(&descriptor);
  ::dawn::BufferCopyView copy_buffer_view =
      CreateBufferCopyView(copy_buffer, 0, dawn_row_pitch, 0);
  ::dawn::Origin3D origin3D;
  origin3D.x = 0;
  origin3D.y = 0;
  origin3D.z = 0;

  for (uint32_t i = 0;
       i < render_pipeline.pipeline->GetColorAttachments().size(); i++) {
    ::dawn::TextureCopyView device_texture_view =
        CreateTextureCopyView(textures_[i], 0, 0, origin3D);
    ::dawn::Extent3D copySize = {width, height, 1};
    auto encoder = device.CreateCommandEncoder();
    encoder.CopyTextureToBuffer(&device_texture_view, &copy_buffer_view,
                                &copySize);
    auto commands = encoder.Finish();
    auto queue = device.CreateQueue();
    queue.Submit(1, &commands);

    MapResult mapped_device_texture = MapBuffer(device, copy_buffer);
    if (!mapped_device_texture.result.IsSuccess())
      return mapped_device_texture.result;

    auto& host_texture = render_pipeline.pipeline->GetColorAttachments()[i];
    auto* values = host_texture.buffer->ValuePtr();
    auto row_stride = pixelSize * width;
    assert(row_stride * height == host_texture.buffer->GetSizeInBytes());
    // Each Dawn row has enough data to fill the target row.
    assert(dawn_row_pitch >= row_stride);
    values->resize(host_texture.buffer->GetSizeInBytes());
    // Copy the framebuffer contents back into the host-side
    // framebuffer-buffer. In the Dawn buffer, the row stride is a multiple of
    // kMinimumImageRowPitch bytes, so it might have padding therefore memcpy
    // is done row by row.
    for (uint h = 0; h < height; h++) {
      std::memcpy(values->data() + h * row_stride,
                  static_cast<const uint8_t*>(mapped_device_texture.data) +
                      h * dawn_row_pitch,
                  row_stride);
    }
    // Always unmap the buffer at the end of the engine's command.
    copy_buffer.Unmap();
  }
  return {};
}

Result EngineDawn::MapDeviceBufferToHostBuffer(
    const ComputePipelineInfo& compute_pipeline,
    const ::dawn::Device& device) {
  for (uint32_t i = 0; i < compute_pipeline.pipeline->GetBuffers().size();
       i++) {
    auto& device_buffer = compute_pipeline.buffers[i];
    auto& host_buffer = compute_pipeline.pipeline->GetBuffers()[i];

    // Create a copy of device buffer to use it in a map read operation.
    // It's not possible to simply set this bit on the existing buffers since:
    // Device error: Only CopyDst is allowed with MapRead
    ::dawn::BufferDescriptor descriptor;
    descriptor.size = host_buffer.buffer->GetSizeInBytes();
    descriptor.usage =
        ::dawn::BufferUsage::CopyDst | ::dawn::BufferUsage::MapRead;
    const auto copy_device_buffer = device.CreateBuffer(&descriptor);
    const uint64_t source_offset = 0;
    const uint64_t destination_offset = 0;
    const uint64_t copy_size =
        static_cast<uint64_t>(host_buffer.buffer->GetSizeInBytes());
    auto encoder = device.CreateCommandEncoder();
    encoder.CopyBufferToBuffer(device_buffer, source_offset, copy_device_buffer,
                               destination_offset, copy_size);
    auto commands = encoder.Finish();
    auto queue = device.CreateQueue();
    queue.Submit(1, &commands);

    MapResult mapped_device_buffer = MapBuffer(device, copy_device_buffer);
    auto* values = host_buffer.buffer->ValuePtr();
    values->resize(host_buffer.buffer->GetSizeInBytes());
    std::memcpy(values->data(),
                static_cast<const uint8_t*>(mapped_device_buffer.data),
                copy_size);

    copy_device_buffer.Unmap();
    if (!mapped_device_buffer.result.IsSuccess())
      return mapped_device_buffer.result;
  }
  return {};
}

// Creates a dawn buffer of |size| bytes with TransferDst and the given usage
// copied from Dawn utils source code
::dawn::Buffer CreateBufferFromData(const ::dawn::Device& device,
                                    const void* data,
                                    uint64_t size,
                                    ::dawn::BufferUsage usage) {
  ::dawn::BufferDescriptor descriptor;
  descriptor.size = size;
  descriptor.usage = usage | ::dawn::BufferUsage::CopyDst;

  ::dawn::Buffer buffer = device.CreateBuffer(&descriptor);
  if (data != nullptr)
    buffer.SetSubData(0, size, reinterpret_cast<const uint8_t*>(data));
  return buffer;
}

// Creates a bind group.
// Helpers to make creating bind groups look nicer:
//
//   utils::MakeBindGroup(device, layout, {
//       {0, mySampler},
//       {1, myBuffer, offset, size},
//       {3, myTexture}
//   });

// Structure with one constructor per-type of bindings, so that the
// initializer_list accepts bindings with the right type and no extra
// information.
struct BindingInitializationHelper {
  BindingInitializationHelper(uint32_t binding,
                              const ::dawn::Buffer& buffer,
                              uint64_t offset,
                              uint64_t size)
      : binding(binding), buffer(buffer), offset(offset), size(size) {}

  ::dawn::BindGroupBinding GetAsBinding() const {
    ::dawn::BindGroupBinding result;
    result.binding = binding;
    result.sampler = sampler;
    result.textureView = textureView;
    result.buffer = buffer;
    result.offset = offset;
    result.size = size;
    return result;
  }

  uint32_t binding;
  ::dawn::Sampler sampler;
  ::dawn::TextureView textureView;
  ::dawn::Buffer buffer;
  uint64_t offset = 0;
  uint64_t size = 0;
};

::dawn::BindGroup MakeBindGroup(
    const ::dawn::Device& device,
    const ::dawn::BindGroupLayout& layout,
    const std::vector<BindingInitializationHelper>& bindingsInitializer) {
  std::vector<::dawn::BindGroupBinding> bindings;
  for (const BindingInitializationHelper& helper : bindingsInitializer) {
    bindings.push_back(helper.GetAsBinding());
  }

  ::dawn::BindGroupDescriptor descriptor;
  descriptor.layout = layout;
  descriptor.bindingCount = bindings.size();
  descriptor.bindings = bindings.data();

  return device.CreateBindGroup(&descriptor);
}

// Creates a bind group layout.
// Copied from Dawn utils source code.
::dawn::BindGroupLayout MakeBindGroupLayout(
    const ::dawn::Device& device,
    const std::vector<::dawn::BindGroupLayoutBinding>& bindingsInitializer) {
  constexpr ::dawn::ShaderStage kNoStages{};

  std::vector<::dawn::BindGroupLayoutBinding> bindings;
  for (const ::dawn::BindGroupLayoutBinding& binding : bindingsInitializer) {
    if (binding.visibility != kNoStages) {
      bindings.push_back(binding);
    }
  }

  ::dawn::BindGroupLayoutDescriptor descriptor;
  descriptor.bindingCount = static_cast<uint32_t>(bindings.size());
  descriptor.bindings = bindings.data();
  return device.CreateBindGroupLayout(&descriptor);
}

// Creates a basic pipeline layout.
// Copied from Dawn utils source code.
::dawn::PipelineLayout MakeBasicPipelineLayout(
    const ::dawn::Device& device,
    std::vector<::dawn::BindGroupLayout> bindingInitializer) {
  ::dawn::PipelineLayoutDescriptor descriptor;
  descriptor.bindGroupLayoutCount = bindingInitializer.size();
  descriptor.bindGroupLayouts = bindingInitializer.data();
  return device.CreatePipelineLayout(&descriptor);
}

// Converts an Amber format to a Dawn texture format, and sends the result out
// through |dawn_format_ptr|.  If the conversion fails, return an error
// result.
Result GetDawnTextureFormat(const ::amber::Format& amber_format,
                            ::dawn::TextureFormat* dawn_format_ptr) {
  if (!dawn_format_ptr)
    return Result(""Internal error: format pointer argument is null"");
  ::dawn::TextureFormat& dawn_format = *dawn_format_ptr;

  switch (amber_format.GetFormatType()) {
    // TODO(dneto): These are all the formats that Dawn currently knows about.
    case FormatType::kR8G8B8A8_UNORM:
      dawn_format = ::dawn::TextureFormat::RGBA8Unorm;
      break;
    case FormatType::kR8G8_UNORM:
      dawn_format = ::dawn::TextureFormat::RG8Unorm;
      break;
    case FormatType::kR8_UNORM:
      dawn_format = ::dawn::TextureFormat::R8Unorm;
      break;
    case FormatType::kR8G8B8A8_UINT:
      dawn_format = ::dawn::TextureFormat::RGBA8Uint;
      break;
    case FormatType::kR8G8_UINT:
      dawn_format = ::dawn::TextureFormat::RG8Uint;
      break;
    case FormatType::kR8_UINT:
      dawn_format = ::dawn::TextureFormat::R8Uint;
      break;
    case FormatType::kB8G8R8A8_UNORM:
      dawn_format = ::dawn::TextureFormat::BGRA8Unorm;
      break;
    case FormatType::kD32_SFLOAT_S8_UINT:
      dawn_format = ::dawn::TextureFormat::Depth24PlusStencil8;
      break;
    default:
      return Result(
          ""Amber format "" +
          std::to_string(static_cast<uint32_t>(amber_format.GetFormatType())) +
          "" is invalid for Dawn"");
  }

  return {};
}
// Converts an Amber format to a Dawn Vertex format, and sends the result out
// through |dawn_format_ptr|.  If the conversion fails, return an error
// result.
// TODO(sarahM0): support other ::dawn::VertexFormat
Result GetDawnVertexFormat(const ::amber::Format& amber_format,
                           ::dawn::VertexFormat* dawn_format_ptr) {
  ::dawn::VertexFormat& dawn_format = *dawn_format_ptr;
  switch (amber_format.GetFormatType()) {
    case FormatType::kR32_SFLOAT:
      dawn_format = ::dawn::VertexFormat::Float;
      break;
    case FormatType::kR32G32_SFLOAT:
      dawn_format = ::dawn::VertexFormat::Float2;
      break;
    case FormatType::kR32G32B32_SFLOAT:
      dawn_format = ::dawn::VertexFormat::Float3;
      break;
    case FormatType::kR32G32B32A32_SFLOAT:
      dawn_format = ::dawn::VertexFormat::Float4;
      break;
    case FormatType::kR8G8_SNORM:
      dawn_format = ::dawn::VertexFormat::Char2Norm;
      break;
    case FormatType::kR8G8B8A8_UNORM:
      dawn_format = ::dawn::VertexFormat::UChar4Norm;
      break;
    case FormatType::kR8G8B8A8_SNORM:
      dawn_format = ::dawn::VertexFormat::Char4Norm;
      break;
    default:
      return Result(
          ""Amber vertex format "" +
          std::to_string(static_cast<uint32_t>(amber_format.GetFormatType())) +
          "" is invalid for Dawn or is not supported in amber-dawn"");
  }
  return {};
}

// Converts an Amber format to a Dawn Index format, and sends the result out
// through |dawn_format_ptr|.  If the conversion fails, return an error
// result.
Result GetDawnIndexFormat(const ::amber::Format& amber_format,
                          ::dawn::IndexFormat* dawn_format_ptr) {
  ::dawn::IndexFormat& dawn_format = *dawn_format_ptr;
  switch (amber_format.GetFormatType()) {
    case FormatType::kR16_UINT:
      dawn_format = ::dawn::IndexFormat::Uint16;
      break;
    case FormatType::kR32_UINT:
      dawn_format = ::dawn::IndexFormat::Uint32;
      break;
    default:
      return Result(
          ""Amber index format "" +
          std::to_string(static_cast<uint32_t>(amber_format.GetFormatType())) +
          "" is invalid for Dawn"");
  }
  return {};
}

// Converts an Amber topology to a Dawn topology, and sends the result out
// through |dawn_topology_ptr|. It the conversion fails, return an error result.
Result GetDawnTopology(const ::amber::Topology& amber_topology,
                       ::dawn::PrimitiveTopology* dawn_topology_ptr) {
  ::dawn::PrimitiveTopology& dawn_topology = *dawn_topology_ptr;
  switch (amber_topology) {
    case Topology::kPointList:
      dawn_topology = ::dawn::PrimitiveTopology::PointList;
      break;
    case Topology::kLineList:
      dawn_topology = ::dawn::PrimitiveTopology::LineList;
      break;
    case Topology::kLineStrip:
      dawn_topology = ::dawn::PrimitiveTopology::LineStrip;
      break;
    case Topology::kTriangleList:
      dawn_topology = ::dawn::PrimitiveTopology::TriangleList;
      break;
    case Topology::kTriangleStrip:
      dawn_topology = ::dawn::PrimitiveTopology::TriangleStrip;
      break;
    default:
      return Result(""Amber PrimitiveTopology "" +
                    std::to_string(static_cast<uint32_t>(amber_topology)) +
                    "" is not supported in Dawn"");
  }
  return {};
}

::dawn::CompareFunction GetDawnCompareOp(::amber::CompareOp op) {
  switch (op) {
    case CompareOp::kNever:
      return ::dawn::CompareFunction::Never;
    case CompareOp::kLess:
      return ::dawn::CompareFunction::Less;
    case CompareOp::kEqual:
      return ::dawn::CompareFunction::Equal;
    case CompareOp::kLessOrEqual:
      return ::dawn::CompareFunction::LessEqual;
    case CompareOp::kGreater:
      return ::dawn::CompareFunction::Greater;
    case CompareOp::kNotEqual:
      return ::dawn::CompareFunction::NotEqual;
    case CompareOp::kGreaterOrEqual:
      return ::dawn::CompareFunction::GreaterEqual;
    case CompareOp::kAlways:
      return ::dawn::CompareFunction::Always;
    default:
      return ::dawn::CompareFunction::Never;
  }
}

::dawn::StencilOperation GetDawnStencilOp(::amber::StencilOp op) {
  switch (op) {
    case StencilOp::kKeep:
      return ::dawn::StencilOperation::Keep;
    case StencilOp::kZero:
      return ::dawn::StencilOperation::Zero;
    case StencilOp::kReplace:
      return ::dawn::StencilOperation::Replace;
    case StencilOp::kIncrementAndClamp:
      return ::dawn::StencilOperation::IncrementClamp;
    case StencilOp::kDecrementAndClamp:
      return ::dawn::StencilOperation::DecrementClamp;
    case StencilOp::kInvert:
      return ::dawn::StencilOperation::Invert;
    case StencilOp::kIncrementAndWrap:
      return ::dawn::StencilOperation::IncrementWrap;
    case StencilOp::kDecrementAndWrap:
      return ::dawn::StencilOperation::DecrementWrap;
    default:
      return ::dawn::StencilOperation::Keep;
  }
}

::dawn::BlendFactor GetDawnBlendFactor(::amber::BlendFactor factor) {
  switch (factor) {
    case BlendFactor::kZero:
      return ::dawn::BlendFactor::Zero;
    case BlendFactor::kOne:
      return ::dawn::BlendFactor::One;
    case BlendFactor::kSrcColor:
      return ::dawn::BlendFactor::SrcColor;
    case BlendFactor::kOneMinusSrcColor:
      return ::dawn::BlendFactor::OneMinusSrcColor;
    case BlendFactor::kDstColor:
      return ::dawn::BlendFactor::DstColor;
    case BlendFactor::kOneMinusDstColor:
      return ::dawn::BlendFactor::OneMinusDstColor;
    case BlendFactor::kSrcAlpha:
      return ::dawn::BlendFactor::SrcAlpha;
    case BlendFactor::kOneMinusSrcAlpha:
      return ::dawn::BlendFactor::OneMinusSrcAlpha;
    case BlendFactor::kDstAlpha:
      return ::dawn::BlendFactor::DstAlpha;
    case BlendFactor::kOneMinusDstAlpha:
      return ::dawn::BlendFactor::OneMinusDstAlpha;
    case BlendFactor::kSrcAlphaSaturate:
      return ::dawn::BlendFactor::SrcAlphaSaturated;
    default:
      assert(false && ""Dawn::Unknown BlendFactor"");
      return ::dawn::BlendFactor::One;
  }
}

::dawn::BlendOperation GetDawnBlendOperation(BlendOp op) {
  switch (op) {
    case BlendOp::kAdd:
      return ::dawn::BlendOperation::Add;
    case BlendOp::kSubtract:
      return ::dawn::BlendOperation::Subtract;
    case BlendOp::kReverseSubtract:
      return ::dawn::BlendOperation::ReverseSubtract;
    case BlendOp::kMin:
      return ::dawn::BlendOperation::Min;
    case BlendOp::kMax:
      return ::dawn::BlendOperation::Max;
    default:
      assert(false && ""Dawn::Unknown BlendOp"");
      return ::dawn::BlendOperation::Add;
  }
}

::dawn::ColorWriteMask GetDawnColorWriteMask(uint8_t amber_color_write_mask) {
  if (amber_color_write_mask == 0x00000000)
    return ::dawn::ColorWriteMask::None;
  else if (amber_color_write_mask == 0x00000001)
    return ::dawn::ColorWriteMask::Red;
  else if (amber_color_write_mask == 0x00000002)
    return ::dawn::ColorWriteMask::Green;
  else if (amber_color_write_mask == 0x00000004)
    return ::dawn::ColorWriteMask::Blue;
  else if (amber_color_write_mask == 0x00000008)
    return ::dawn::ColorWriteMask::Alpha;
  else if (amber_color_write_mask == 0x0000000F)
    return ::dawn::ColorWriteMask::All;
  else
    assert(false && ""Dawn::Unknown ColorWriteMask"");
  return ::dawn::ColorWriteMask::All;
}

::dawn::FrontFace GetDawnFrontFace(FrontFace amber_front_face) {
  return amber_front_face == FrontFace::kClockwise ? ::dawn::FrontFace::CW
                                                   : ::dawn::FrontFace::CCW;
}

::dawn::CullMode GetDawnCullMode(CullMode amber_cull_mode) {
  switch (amber_cull_mode) {
    case CullMode::kNone:
      return ::dawn::CullMode::None;
    case CullMode::kFront:
      return ::dawn::CullMode::Front;
    case CullMode::kBack:
      return ::dawn::CullMode::Back;
    default:
      assert(false && ""Dawn::Unknown CullMode"");
      return ::dawn::CullMode::None;
  }
}

EngineDawn::EngineDawn() : Engine() {}

EngineDawn::~EngineDawn() = default;

Result EngineDawn::Initialize(EngineConfig* config,
                              Delegate*,
                              const std::vector<std::string>&,
                              const std::vector<std::string>&,
                              const std::vector<std::string>&) {
  if (device_)
    return Result(""Dawn:Initialize device_ already exists"");

  if (!config)
    return Result(""Dawn::Initialize config is null"");
  DawnEngineConfig* dawn_config = static_cast<DawnEngineConfig*>(config);
  if (dawn_config->device == nullptr)
    return Result(""Dawn:Initialize device is a null pointer"");

  device_ = dawn_config->device;

  return {};
}

Result EngineDawn::CreatePipeline(::amber::Pipeline* pipeline) {
  if (!device_) {
    return Result(""Dawn::CreatePipeline: device is not created"");
  }
  std::unordered_map<ShaderType, ::dawn::ShaderModule, CastHash<ShaderType>>
      module_for_type;
  ::dawn::ShaderModuleDescriptor descriptor;
  descriptor.nextInChain = nullptr;

  for (const auto& shader_info : pipeline->GetShaders()) {
    ShaderType type = shader_info.GetShaderType();
    const std::vector<uint32_t>& code = shader_info.GetData();
    descriptor.code = code.data();
    descriptor.codeSize = uint32_t(code.size());

    auto shader = device_->CreateShaderModule(&descriptor);
    if (!shader) {
      return Result(""Dawn::CreatePipeline: failed to create shader"");
    }
    if (module_for_type.count(type)) {
      return Result(""Dawn::CreatePipeline: module for type already exists"");
    }
    module_for_type[type] = shader;
  }

  switch (pipeline->GetType()) {
    case PipelineType::kCompute: {
      auto& module = module_for_type[kShaderTypeCompute];
      if (!module)
        return Result(""Dawn::CreatePipeline: no compute shader provided"");

      pipeline_map_[pipeline].compute_pipeline.reset(
          new ComputePipelineInfo(pipeline, module));
      Result result =
          AttachBuffers(pipeline_map_[pipeline].compute_pipeline.get());
      if (!result.IsSuccess())
        return result;
      break;
    }

    case PipelineType::kGraphics: {
      // TODO(dneto): Handle other shader types as well.  They are optional.
      auto& vs = module_for_type[kShaderTypeVertex];
      auto& fs = module_for_type[kShaderTypeFragment];
      if (!vs) {
        return Result(
            ""Dawn::CreatePipeline: no vertex shader provided for graphics ""
            ""pipeline"");
      }
      if (!fs) {
        return Result(
            ""Dawn::CreatePipeline: no fragment shader provided for graphics ""
            ""pipeline"");
      }

      pipeline_map_[pipeline].render_pipeline.reset(
          new RenderPipelineInfo(pipeline, vs, fs));
      Result result = AttachBuffersAndTextures(
          pipeline_map_[pipeline].render_pipeline.get());
      if (!result.IsSuccess())
        return result;

      break;
    }
  }

  return {};
}

Result EngineDawn::DoClearColor(const ClearColorCommand* command) {
  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (!render_pipeline)
    return Result(""ClearColor invoked on invalid or missing render pipeline"");

  render_pipeline->clear_color_value = ::dawn::Color{
      command->GetR(), command->GetG(), command->GetB(), command->GetA()};

  return {};
}

Result EngineDawn::DoClearStencil(const ClearStencilCommand* command) {
  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (!render_pipeline)
    return Result(""ClearStencil invoked on invalid or missing render pipeline"");

  render_pipeline->clear_stencil_value = command->GetValue();
  return {};
}

Result EngineDawn::DoClearDepth(const ClearDepthCommand* command) {
  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (!render_pipeline)
    return Result(""ClearDepth invoked on invalid or missing render pipeline"");

  render_pipeline->clear_depth_value = command->GetValue();
  return {};
}

Result EngineDawn::DoClear(const ClearCommand* command) {
  Result result;
  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (!render_pipeline)
    return Result(""Clear invoked on invalid or missing render pipeline"");

  DawnPipelineHelper helper;
  result = helper.CreateRenderPipelineDescriptor(*render_pipeline, *device_,
                                                 false, nullptr);
  if (!result.IsSuccess())
    return result;
  result = helper.CreateRenderPassDescriptor(
      *render_pipeline, *device_, texture_views_, ::dawn::LoadOp::Clear);
  if (!result.IsSuccess())
    return result;

  ::dawn::RenderPassDescriptor* renderPassDescriptor =
      &helper.renderPassDescriptor;
  ::dawn::CommandEncoder encoder = device_->CreateCommandEncoder();
  ::dawn::RenderPassEncoder pass =
      encoder.BeginRenderPass(renderPassDescriptor);
  pass.EndPass();

  ::dawn::CommandBuffer commands = encoder.Finish();
  ::dawn::Queue queue = device_->CreateQueue();
  queue.Submit(1, &commands);

  result = MapDeviceTextureToHostBuffer(*render_pipeline, *device_);

  return result;
}

// Creates a Dawn render pipeline descriptor for the given pipeline on the given
// device. When |ignore_vertex_and_Index_buffers| is true, ignores the vertex
// and index buffers attached to |render_pipeline| and instead configures the
// resulting descriptor to have a single vertex buffer with an attribute format
// of Float4 and input stride of 4*sizeof(float)
Result DawnPipelineHelper::CreateRenderPipelineDescriptor(
    const RenderPipelineInfo& render_pipeline,
    const ::dawn::Device& device,
    const bool ignore_vertex_and_Index_buffers,
    const PipelineData* pipeline_data) {
  Result result;

  auto* amber_format =
      render_pipeline.pipeline->GetColorAttachments()[0].buffer->GetFormat();
  if (!amber_format)
    return Result(""Color attachment 0 has no format!"");
  ::dawn::TextureFormat fb_format{};
  result = GetDawnTextureFormat(*amber_format, &fb_format);
  if (!result.IsSuccess())
    return result;

  ::dawn::TextureFormat depth_stencil_format{};
  auto* depthBuffer = render_pipeline.pipeline->GetDepthBuffer().buffer;
  if (depthBuffer) {
    auto* amber_depth_stencil_format = depthBuffer->GetFormat();
    if (!amber_depth_stencil_format)
      return Result(""The depth/stencil attachment has no format!"");
    result = GetDawnTextureFormat(*amber_depth_stencil_format,
                                  &depth_stencil_format);
    if (!result.IsSuccess())
      return result;
  } else {
    depth_stencil_format = ::dawn::TextureFormat::Depth24PlusStencil8;
  }

  renderPipelineDescriptor.layout =
      MakeBasicPipelineLayout(device, render_pipeline.bind_group_layouts);

  renderPipelineDescriptor.primitiveTopology =
      ::dawn::PrimitiveTopology::TriangleList;
  renderPipelineDescriptor.sampleCount = 1;

  // Lookup shaders' entrypoints
  for (const auto& shader_info : render_pipeline.pipeline->GetShaders()) {
    if (shader_info.GetShaderType() == kShaderTypeVertex) {
      vertexEntryPoint = shader_info.GetEntryPoint();
    } else if (shader_info.GetShaderType() == kShaderTypeFragment) {
      fragmentEntryPoint = shader_info.GetEntryPoint();
    } else {
      return Result(
          ""CreateRenderPipelineDescriptor: An unknown shader is attached to ""
          ""the render pipeline"");
    }
  }
  // Fill the default values for vertexInput (buffers and attributes).
  // assuming #buffers == #attributes
  vertexInputDescriptor.bufferCount =
      render_pipeline.pipeline->GetVertexBuffers().size();

  for (uint32_t i = 0; i < kMaxVertexInputs; ++i) {
    if (ignore_vertex_and_Index_buffers) {
      if (i == 0) {
        vertexInputDescriptor.bufferCount = 1;
        vertexInputDescriptor.cBuffers[0].attributeCount = 1;
        vertexInputDescriptor.cBuffers[0].stride = 4 * sizeof(float);
        vertexInputDescriptor.cBuffers[0].attributes =
            &vertexInputDescriptor.cAttributes[0];

        vertexInputDescriptor.cAttributes[0].shaderLocation = 0;
        vertexInputDescriptor.cAttributes[0].format =
            ::dawn::VertexFormat::Float4;
      }
    } else {
      if (i < render_pipeline.pipeline->GetVertexBuffers().size()) {
        vertexInputDescriptor.cBuffers[i].attributeCount = 1;
        vertexInputDescriptor.cBuffers[i].stride =
            render_pipeline.pipeline->GetVertexBuffers()[i]
                .buffer->GetElementStride();
        vertexInputDescriptor.cBuffers[i].stepMode =
            ::dawn::InputStepMode::Vertex;
        vertexInputDescriptor.cBuffers[i].attributes =
            &vertexInputDescriptor.cAttributes[i];

        vertexInputDescriptor.cAttributes[i].shaderLocation = i;
        auto* amber_vertex_format =
            render_pipeline.pipeline->GetVertexBuffers()[i].buffer->GetFormat();
        result = GetDawnVertexFormat(
            *amber_vertex_format, &vertexInputDescriptor.cAttributes[i].format);
        if (!result.IsSuccess())
          return result;
      }
    }
  }

  // set index buffer format
  if (render_pipeline.pipeline->GetIndexBuffer()) {
    auto* amber_index_format =
        render_pipeline.pipeline->GetIndexBuffer()->GetFormat();
    GetDawnIndexFormat(*amber_index_format, &vertexInputDescriptor.indexFormat);
    if (!result.IsSuccess())
      return result;
  }

  renderPipelineDescriptor.vertexInput =
      reinterpret_cast<::dawn::VertexInputDescriptor*>(&vertexInputDescriptor);

  // Set defaults for the vertex stage descriptor.
  vertexStage.module = render_pipeline.vertex_shader;
  vertexStage.entryPoint = vertexEntryPoint.c_str();
  renderPipelineDescriptor.vertexStage = vertexStage;

  // Set defaults for the fragment stage descriptor.
  fragmentStage.module = render_pipeline.fragment_shader;
  fragmentStage.entryPoint = fragmentEntryPoint.c_str();
  renderPipelineDescriptor.fragmentStage = std::move(&fragmentStage);

  // Set defaults for the rasterization state descriptor.
  if (pipeline_data == nullptr) {
    rasterizationState.frontFace = ::dawn::FrontFace::CCW;
    rasterizationState.cullMode = ::dawn::CullMode::None;
    rasterizationState.depthBias = 0;
    rasterizationState.depthBiasSlopeScale = 0.0;
    rasterizationState.depthBiasClamp = 0.0;
    renderPipelineDescriptor.rasterizationState = &rasterizationState;
  } else {
    rasterizationState.frontFace =
        GetDawnFrontFace(pipeline_data->GetFrontFace());
    rasterizationState.cullMode = GetDawnCullMode(pipeline_data->GetCullMode());
    rasterizationState.depthBias = pipeline_data->GetEnableDepthBias();
    rasterizationState.depthBiasSlopeScale =
        pipeline_data->GetDepthBiasSlopeFactor();
    rasterizationState.depthBiasClamp = pipeline_data->GetDepthBiasClamp();
    renderPipelineDescriptor.rasterizationState = &rasterizationState;
  }

  // Set defaults for the color state descriptors.
  if (pipeline_data == nullptr) {
    renderPipelineDescriptor.colorStateCount =
        render_pipeline.pipeline->GetColorAttachments().size();
    alpha_blend.operation = ::dawn::BlendOperation::Add;
    alpha_blend.srcFactor = ::dawn::BlendFactor::One;
    alpha_blend.dstFactor = ::dawn::BlendFactor::Zero;
    colorStateDescriptor.writeMask = ::dawn::ColorWriteMask::All;
    colorStateDescriptor.format = fb_format;
    colorStateDescriptor.alphaBlend = alpha_blend;
    colorStateDescriptor.colorBlend = alpha_blend;
  } else {
    renderPipelineDescriptor.colorStateCount =
        render_pipeline.pipeline->GetColorAttachments().size();

    alpha_blend.operation =
        GetDawnBlendOperation(pipeline_data->GetColorBlendOp());
    alpha_blend.srcFactor =
        GetDawnBlendFactor(pipeline_data->GetSrcAlphaBlendFactor());
    alpha_blend.dstFactor =
        GetDawnBlendFactor(pipeline_data->GetDstAlphaBlendFactor());

    color_blend.operation =
        GetDawnBlendOperation(pipeline_data->GetAlphaBlendOp());
    color_blend.srcFactor =
        GetDawnBlendFactor(pipeline_data->GetSrcColorBlendFactor());
    color_blend.dstFactor =
        GetDawnBlendFactor(pipeline_data->GetDstAlphaBlendFactor());

    colorStateDescriptor.writeMask =
        GetDawnColorWriteMask(pipeline_data->GetColorWriteMask());

    colorStateDescriptor.format = fb_format;
    colorStateDescriptor.alphaBlend = alpha_blend;
    colorStateDescriptor.colorBlend = color_blend;
  }

  for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
    ::dawn::TextureFormat fb_format{};
    {
      if (i < render_pipeline.pipeline->GetColorAttachments().size()) {
        auto* amber_format = render_pipeline.pipeline->GetColorAttachments()[i]
                                 .buffer->GetFormat();
        if (!amber_format)
          return Result(
              ""AttachBuffersAndTextures: One Color attachment has no ""
              ""format!"");
        result = GetDawnTextureFormat(*amber_format, &fb_format);
        if (!result.IsSuccess())
          return result;
      } else {
        fb_format = ::dawn::TextureFormat::RGBA8Unorm;
      }
    }
    colorStatesDescriptor[i] = colorStateDescriptor;
    colorStates[i] = &colorStatesDescriptor[i];
    colorStates[i]->format = fb_format;
  }
  renderPipelineDescriptor.colorStates = &colorStates[0];

  // Set defaults for the depth stencil state descriptors.
  if (pipeline_data == nullptr) {
    stencil_front.compare = ::dawn::CompareFunction::Always;
    stencil_front.failOp = ::dawn::StencilOperation::Keep;
    stencil_front.depthFailOp = ::dawn::StencilOperation::Keep;
    stencil_front.passOp = ::dawn::StencilOperation::Keep;
    depthStencilState.depthWriteEnabled = false;
    depthStencilState.depthCompare = ::dawn::CompareFunction::Always;
    depthStencilState.stencilBack = stencil_front;
    depthStencilState.stencilFront = stencil_front;
    depthStencilState.stencilReadMask = 0xff;
    depthStencilState.stencilWriteMask = 0xff;
    depthStencilState.format = depth_stencil_format;
    renderPipelineDescriptor.depthStencilState = &depthStencilState;
  } else {
    stencil_front.compare =
        GetDawnCompareOp(pipeline_data->GetFrontCompareOp());
    stencil_front.failOp = GetDawnStencilOp(pipeline_data->GetFrontFailOp());
    stencil_front.depthFailOp =
        GetDawnStencilOp(pipeline_data->GetFrontDepthFailOp());
    stencil_front.passOp = GetDawnStencilOp(pipeline_data->GetFrontPassOp());

    stencil_back.compare = GetDawnCompareOp(pipeline_data->GetBackCompareOp());
    stencil_back.failOp = GetDawnStencilOp(pipeline_data->GetBackFailOp());
    stencil_back.depthFailOp =
        GetDawnStencilOp(pipeline_data->GetBackDepthFailOp());
    stencil_back.passOp = GetDawnStencilOp(pipeline_data->GetBackPassOp());

    depthStencilState.depthWriteEnabled = pipeline_data->GetEnableDepthWrite();
    depthStencilState.depthCompare =
        GetDawnCompareOp(pipeline_data->GetDepthCompareOp());
    depthStencilState.stencilFront = stencil_front;
    depthStencilState.stencilBack = stencil_back;
    // WebGPU doesn't support separate front and back stencil mask, they has to
    // be the same
    depthStencilState.stencilReadMask =
        (pipeline_data->GetFrontCompareMask() ==
         pipeline_data->GetBackCompareMask())
            ? pipeline_data->GetFrontCompareMask()
            : 0xff;
    depthStencilState.stencilWriteMask = (pipeline_data->GetBackWriteMask() ==
                                          pipeline_data->GetFrontWriteMask())
                                             ? pipeline_data->GetBackWriteMask()
                                             : 0xff;
    depthStencilState.format = depth_stencil_format;
    renderPipelineDescriptor.depthStencilState = &depthStencilState;
  }

  return {};
}

Result DawnPipelineHelper::CreateRenderPassDescriptor(
    const RenderPipelineInfo& render_pipeline,
    const ::dawn::Device& device,
    const std::vector<::dawn::TextureView>& texture_view,
    const ::dawn::LoadOp load_op) {
  for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
    colorAttachmentsInfo[i].loadOp = load_op;
    colorAttachmentsInfo[i].storeOp = ::dawn::StoreOp::Store;
    colorAttachmentsInfo[i].clearColor = render_pipeline.clear_color_value;
    colorAttachmentsInfoPtr[i] = nullptr;
  }

  depthStencilAttachmentInfo.clearDepth = render_pipeline.clear_depth_value;
  depthStencilAttachmentInfo.clearStencil = render_pipeline.clear_stencil_value;
  depthStencilAttachmentInfo.depthLoadOp = load_op;
  depthStencilAttachmentInfo.depthStoreOp = ::dawn::StoreOp::Store;
  depthStencilAttachmentInfo.stencilLoadOp = load_op;
  depthStencilAttachmentInfo.stencilStoreOp = ::dawn::StoreOp::Store;

  renderPassDescriptor.colorAttachmentCount =
      render_pipeline.pipeline->GetColorAttachments().size();
  uint32_t colorAttachmentIndex = 0;
  for (const ::dawn::TextureView& colorAttachment : texture_view) {
    if (colorAttachment.Get() != nullptr) {
      colorAttachmentsInfo[colorAttachmentIndex].attachment = colorAttachment;
      colorAttachmentsInfoPtr[colorAttachmentIndex] =
          &colorAttachmentsInfo[colorAttachmentIndex];
    }
    ++colorAttachmentIndex;
  }
  renderPassDescriptor.colorAttachments = colorAttachmentsInfoPtr;

  ::dawn::TextureFormat depth_stencil_format{};
  auto* depthBuffer = render_pipeline.pipeline->GetDepthBuffer().buffer;
  if (depthBuffer) {
    auto* amber_depth_stencil_format = depthBuffer->GetFormat();
    if (!amber_depth_stencil_format)
      return Result(""The depth/stencil attachment has no format!"");
    Result result = GetDawnTextureFormat(*amber_depth_stencil_format,
                                         &depth_stencil_format);
    if (!result.IsSuccess())
      return result;
  } else {
    depth_stencil_format = ::dawn::TextureFormat::Depth24PlusStencil8;
  }

  depthStencilDescriptor.dimension = ::dawn::TextureDimension::e2D;
  depthStencilDescriptor.size.width =
      render_pipeline.pipeline->GetFramebufferWidth();
  depthStencilDescriptor.size.height =
      render_pipeline.pipeline->GetFramebufferHeight();
  depthStencilDescriptor.size.depth = 1;
  depthStencilDescriptor.arrayLayerCount = 1;
  depthStencilDescriptor.sampleCount = 1;
  depthStencilDescriptor.format = depth_stencil_format;
  depthStencilDescriptor.mipLevelCount = 1;
  depthStencilDescriptor.usage =
      ::dawn::TextureUsage::OutputAttachment | ::dawn::TextureUsage::CopySrc;
  depthStencilTexture = device.CreateTexture(&depthStencilDescriptor);
  depthStencilView = depthStencilTexture.CreateView();

  if (depthStencilView.Get() != nullptr) {
    depthStencilAttachmentInfo.attachment = depthStencilView;
    renderPassDescriptor.depthStencilAttachment = &depthStencilAttachmentInfo;
  } else {
    renderPassDescriptor.depthStencilAttachment = nullptr;
  }

  return {};
}

Result EngineDawn::DoDrawRect(const DrawRectCommand* command) {
  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (!render_pipeline)
    return Result(""DrawRect invoked on invalid or missing render pipeline"");
  if (render_pipeline->vertex_buffers.size() > 1)
    return Result(
        ""DrawRect invoked on a render pipeline with more than one ""
        ""VERTEX_DATA attached"");

  float x = command->GetX();
  float y = command->GetY();
  float rectangleWidth = command->GetWidth();
  float rectangleHeight = command->GetHeight();

  const uint32_t frameWidth = render_pipeline->pipeline->GetFramebufferWidth();
  const uint32_t frameHeight =
      render_pipeline->pipeline->GetFramebufferHeight();

  if (command->IsOrtho()) {
    x = ((x / frameWidth) * 2.0f) - 1.0f;
    y = ((y / frameHeight) * 2.0f) - 1.0f;
    rectangleWidth = (rectangleWidth / frameWidth) * 2.0f;
    rectangleHeight = (rectangleHeight / frameHeight) * 2.0f;
  }

  static const uint32_t indexData[3 * 2] = {
      0, 1, 2, 0, 2, 3,
  };
  auto index_buffer = CreateBufferFromData(
      *device_, indexData, sizeof(indexData), ::dawn::BufferUsage::Index);

  const float vertexData[4 * 4] = {
      // Bottom left
      x,
      y + rectangleHeight,
      0.0f,
      1.0f,
      // Top left
      x,
      y,
      0.0f,
      1.0f,
      // Top right
      x + rectangleWidth,
      y,
      0.0f,
      1.0f,
      // Bottom right
      x + rectangleWidth,
      y + rectangleHeight,
      0.0f,
      1.0f,
  };

  auto vertex_buffer = CreateBufferFromData(
      *device_, vertexData, sizeof(vertexData), ::dawn::BufferUsage::Vertex);
  DawnPipelineHelper helper;
  helper.CreateRenderPipelineDescriptor(*render_pipeline, *device_, true,
                                        command->GetPipelineData());
  helper.CreateRenderPassDescriptor(*render_pipeline, *device_, texture_views_,
                                    ::dawn::LoadOp::Load);
  ::dawn::RenderPipelineDescriptor* renderPipelineDescriptor =
      &helper.renderPipelineDescriptor;
  ::dawn::RenderPassDescriptor* renderPassDescriptor =
      &helper.renderPassDescriptor;

  const ::dawn::RenderPipeline pipeline =
      device_->CreateRenderPipeline(renderPipelineDescriptor);
  static const uint64_t vertexBufferOffsets[1] = {0};
  ::dawn::CommandEncoder encoder = device_->CreateCommandEncoder();
  ::dawn::RenderPassEncoder pass =
      encoder.BeginRenderPass(renderPassDescriptor);
  pass.SetPipeline(pipeline);
  for (uint32_t i = 0; i < render_pipeline->bind_groups.size(); i++) {
    if (render_pipeline->bind_groups[i]) {
      pass.SetBindGroup(i, render_pipeline->bind_groups[i], 0, nullptr);
    }
  }
  pass.SetVertexBuffers(0, 1, &vertex_buffer, vertexBufferOffsets);
  pass.SetIndexBuffer(index_buffer, 0);
  pass.DrawIndexed(6, 1, 0, 0, 0);
  pass.EndPass();

  ::dawn::CommandBuffer commands = encoder.Finish();
  ::dawn::Queue queue = device_->CreateQueue();
  queue.Submit(1, &commands);

  Result result = MapDeviceTextureToHostBuffer(*render_pipeline, *device_);

  return result;
}

Result EngineDawn::DoDrawArrays(const DrawArraysCommand* command) {
  Result result;

  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (!render_pipeline)
    return Result(""DrawArrays invoked on invalid or missing render pipeline"");

  if (command->IsIndexed()) {
    if (!render_pipeline->index_buffer)
      return Result(""DrawArrays: Draw indexed is used without given indices"");
  } else {
    std::vector<uint32_t> indexData;
    for (uint32_t i = 0;
         i < command->GetFirstVertexIndex() + command->GetVertexCount(); i++) {
      indexData.emplace_back(i);
    }
    render_pipeline->index_buffer = CreateBufferFromData(
        *device_, indexData.data(), indexData.size() * sizeof(uint32_t),
        ::dawn::BufferUsage::Index);
  }

  uint32_t instance_count = command->GetInstanceCount();
  if (instance_count == 0 && command->GetVertexCount() != 0)
    instance_count = 1;

  DawnPipelineHelper helper;
  result = helper.CreateRenderPipelineDescriptor(
      *render_pipeline, *device_, false, command->GetPipelineData());
  if (!result.IsSuccess())
    return result;
  result = helper.CreateRenderPassDescriptor(
      *render_pipeline, *device_, texture_views_, ::dawn::LoadOp::Load);
  if (!result.IsSuccess())
    return result;

  ::dawn::RenderPipelineDescriptor* renderPipelineDescriptor =
      &helper.renderPipelineDescriptor;
  ::dawn::RenderPassDescriptor* renderPassDescriptor =
      &helper.renderPassDescriptor;

  result = GetDawnTopology(command->GetTopology(),
                           &renderPipelineDescriptor->primitiveTopology);
  if (!result.IsSuccess())
    return result;

  static const uint64_t vertexBufferOffsets[1] = {0};
  const ::dawn::RenderPipeline pipeline =
      device_->CreateRenderPipeline(renderPipelineDescriptor);
  ::dawn::CommandEncoder encoder = device_->CreateCommandEncoder();
  ::dawn::RenderPassEncoder pass =
      encoder.BeginRenderPass(renderPassDescriptor);
  pass.SetPipeline(pipeline);
  for (uint32_t i = 0; i < render_pipeline->bind_groups.size(); i++) {
    if (render_pipeline->bind_groups[i]) {
      pass.SetBindGroup(i, render_pipeline->bind_groups[i], 0, nullptr);
    }
  }
  // TODO(sarahM0): figure out what are startSlot, count and offsets
  for (uint32_t i = 0; i < render_pipeline->vertex_buffers.size(); i++) {
    pass.SetVertexBuffers(i,                                   /* startSlot */
                          1,                                   /* count */
                          &render_pipeline->vertex_buffers[i], /* buffer */
                          vertexBufferOffsets);                /* offsets */
  }
  // TODO(sarahM0): figure out what this offset means
  pass.SetIndexBuffer(render_pipeline->index_buffer, /* buffer */
                      0);                            /* offset*/
  pass.DrawIndexed(command->GetVertexCount(),        /* indexCount */
                   instance_count,                   /* instanceCount */
                   0,                                /* firstIndex */
                   command->GetFirstVertexIndex(),   /* baseVertex */
                   0 /* firstInstance */);

  pass.EndPass();
  ::dawn::CommandBuffer commands = encoder.Finish();
  ::dawn::Queue queue = device_->CreateQueue();
  queue.Submit(1, &commands);

  result = MapDeviceTextureToHostBuffer(*render_pipeline, *device_);

  return result;
}

Result EngineDawn::DoCompute(const ComputeCommand* command) {
  Result result;

  ComputePipelineInfo* compute_pipeline = GetComputePipeline(command);
  if (!compute_pipeline)
    return Result(""DoComput: invoked on invalid or missing compute pipeline"");

  ::dawn::ComputePipelineDescriptor computePipelineDescriptor;
  computePipelineDescriptor.layout = MakeBasicPipelineLayout(
      device_->Get(), compute_pipeline->bind_group_layouts);

  ::dawn::PipelineStageDescriptor pipelineStageDescriptor;
  pipelineStageDescriptor.module = compute_pipeline->compute_shader;
  pipelineStageDescriptor.entryPoint = ""main"";
  computePipelineDescriptor.computeStage = pipelineStageDescriptor;
  ::dawn::ComputePipeline pipeline =
      device_->CreateComputePipeline(&computePipelineDescriptor);
  ::dawn::CommandEncoder encoder = device_->CreateCommandEncoder();
  ::dawn::ComputePassEncoder pass = encoder.BeginComputePass();
  pass.SetPipeline(pipeline);
  for (uint32_t i = 0; i < compute_pipeline->bind_groups.size(); i++) {
    if (compute_pipeline->bind_groups[i]) {
      pass.SetBindGroup(i, compute_pipeline->bind_groups[i], 0, nullptr);
    }
  }
  pass.Dispatch(command->GetX(), command->GetY(), command->GetZ());
  pass.EndPass();
  // Finish recording the command buffer.  It only has one command.
  auto command_buffer = encoder.Finish();
  // Submit the command.
  auto queue = device_->CreateQueue();
  queue.Submit(1, &command_buffer);
  // Copy result back
  result = MapDeviceBufferToHostBuffer(*compute_pipeline, *device_);

  return result;
}

Result EngineDawn::DoEntryPoint(const EntryPointCommand*) {
  return Result(""Dawn: Entry point must be \\""main\\"" in Dawn"");
}

Result EngineDawn::DoPatchParameterVertices(
    const PatchParameterVerticesCommand*) {
  return Result(""Dawn: PatchParameterVertices is not supported in Dawn"");
}

Result EngineDawn::DoBuffer(const BufferCommand* command) {
  Result result;

  ::dawn::Buffer* dawn_buffer = nullptr;

  const auto descriptor_set = command->GetDescriptorSet();
  const auto binding = command->GetBinding();

  RenderPipelineInfo* render_pipeline = GetRenderPipeline(command);
  if (render_pipeline) {
    auto where = render_pipeline->buffer_map.find({descriptor_set, binding});
    if (where != render_pipeline->buffer_map.end()) {
      const auto dawn_buffer_index = where->second;
      dawn_buffer = &render_pipeline->buffers[dawn_buffer_index];
    }
  }

  ComputePipelineInfo* compute_pipeline = GetComputePipeline(command);
  if (compute_pipeline) {
    auto where = compute_pipeline->buffer_map.find({descriptor_set, binding});
    if (where != compute_pipeline->buffer_map.end()) {
      const auto dawn_buffer_index = where->second;
      dawn_buffer = &compute_pipeline->buffers[dawn_buffer_index];
    }
  }

  if (!render_pipeline && !compute_pipeline)
    return Result(""DoBuffer: invoked on invalid or missing pipeline"");
  if (!command->IsSSBO() && !command->IsUniform())
    return Result(""DoBuffer: only supports SSBO and uniform buffer type"");
  if (!dawn_buffer) {
    return Result(""DoBuffer: no Dawn buffer at descriptor set "" +
                  std::to_string(descriptor_set) + "" and binding "" +
                  std::to_string(binding));
  }

  Buffer* amber_buffer = command->GetBuffer();
  if (amber_buffer) {
    amber_buffer->SetDataWithOffset(command->GetValues(), command->GetOffset());

    dawn_buffer->SetSubData(0, amber_buffer->GetMaxSizeInBytes(),
                            amber_buffer->ValuePtr()->data());
  }

  return {};
}

Result EngineDawn::AttachBuffersAndTextures(
    RenderPipelineInfo* render_pipeline) {
  Result result;
  const uint32_t width = render_pipeline->pipeline->GetFramebufferWidth();
  const uint32_t height = render_pipeline->pipeline->GetFramebufferHeight();

  // Create textures and texture views if we haven't already
  std::vector<int32_t> seen_idx(
      render_pipeline->pipeline->GetColorAttachments().size(), -1);
  for (auto info : render_pipeline->pipeline->GetColorAttachments()) {
    if (info.location >=
        render_pipeline->pipeline->GetColorAttachments().size())
      return Result(""color attachment locations must be sequential from 0"");
    if (seen_idx[info.location] != -1) {
      return Result(""duplicate attachment location: "" +
                    std::to_string(info.location));
    }
    seen_idx[info.location] = static_cast<int32_t>(info.location);
  }

  if (textures_.size() == 0) {
    for (uint32_t i = 0; i < kMaxColorAttachments; i++) {
      ::dawn::TextureFormat fb_format{};

      if (i < render_pipeline->pipeline->GetColorAttachments().size()) {
        auto* amber_format = render_pipeline->pipeline->GetColorAttachments()[i]
                                 .buffer->GetFormat();
        if (!amber_format)
          return Result(
              ""AttachBuffersAndTextures: One Color attachment has no ""
              ""format!"");
        result = GetDawnTextureFormat(*amber_format, &fb_format);
        if (!result.IsSuccess())
          return result;
      } else {
        fb_format = ::dawn::TextureFormat::RGBA8Unorm;
      }

      textures_.emplace_back(
          MakeDawnTexture(*device_, fb_format, width, height));
      texture_views_.emplace_back(textures_.back().CreateView());
    }
  }

  // Attach depth-stencil texture
  auto* depthBuffer = render_pipeline->pipeline->GetDepthBuffer().buffer;
  if (depthBuffer) {
    if (!depth_stencil_texture_) {
      auto* amber_depth_stencil_format = depthBuffer->GetFormat();
      if (!amber_depth_stencil_format)
        return Result(
            ""AttachBuffersAndTextures: The depth/stencil attachment has no ""
            ""format!"");
      ::dawn::TextureFormat depth_stencil_format{};
      result = GetDawnTextureFormat(*amber_depth_stencil_format,
                                    &depth_stencil_format);
      if (!result.IsSuccess())
        return result;

      result = MakeTexture(*device_, depth_stencil_format, width, height,
                           &depth_stencil_texture_);
      if (!result.IsSuccess())
        return result;
      render_pipeline->depth_stencil_texture = depth_stencil_texture_;
    } else {
      render_pipeline->depth_stencil_texture = depth_stencil_texture_;
    }
  }

  // Attach index buffer
  if (render_pipeline->pipeline->GetIndexBuffer()) {
    render_pipeline->index_buffer = CreateBufferFromData(
        *device_,
        render_pipeline->pipeline->GetIndexBuffer()->ValuePtr()->data(),
        render_pipeline->pipeline->GetIndexBuffer()->GetSizeInBytes(),
        ::dawn::BufferUsage::Index);
  }

  // Attach vertex buffers
  for (auto& vertex_info : render_pipeline->pipeline->GetVertexBuffers()) {
    render_pipeline->vertex_buffers.emplace_back(CreateBufferFromData(
        *device_, vertex_info.buffer->ValuePtr()->data(),
        vertex_info.buffer->GetSizeInBytes(), ::dawn::BufferUsage::Vertex));
  }

  // Do not attach pushConstants
  if (render_pipeline->pipeline->GetPushConstantBuffer().buffer != nullptr) {
    return Result(
        ""AttachBuffersAndTextures: Dawn does not support push constants!"");
  }

  ::dawn::ShaderStage kAllStages =
      ::dawn::ShaderStage::Vertex | ::dawn::ShaderStage::Fragment;
  std::vector<std::vector<BindingInitializationHelper>> bindingInitalizerHelper(
      kMaxDawnBindGroup);
  std::vector<std::vector<::dawn::BindGroupLayoutBinding>> layouts_info(
      kMaxDawnBindGroup);
  uint32_t max_descriptor_set = 0;

  // Attach storage/uniform buffers
  ::dawn::BindGroupLayoutBinding empty_layout_info = {};

  if (!render_pipeline->pipeline->GetBuffers().empty()) {
    std::vector<uint32_t> max_binding_seen(kMaxDawnBindGroup, -1);
    for (auto& buf_info : render_pipeline->pipeline->GetBuffers()) {
      while (layouts_info[buf_info.descriptor_set].size() <= buf_info.binding)
        layouts_info[buf_info.descriptor_set].push_back(empty_layout_info);
    }
  }

  for (const auto& buf_info : render_pipeline->pipeline->GetBuffers()) {
    ::dawn::BufferUsage bufferUsage;
    ::dawn::BindingType bindingType;
    switch (buf_info.buffer->GetBufferType()) {
      case BufferType::kStorage: {
        bufferUsage = ::dawn::BufferUsage::Storage;
        bindingType = ::dawn::BindingType::StorageBuffer;
        break;
      }
      case BufferType::kUniform: {
        bufferUsage = ::dawn::BufferUsage::Uniform;
        bindingType = ::dawn::BindingType::UniformBuffer;
        break;
      }
      default: {
        return Result(""AttachBuffersAndTextures: unknown buffer type: "" +
                      std::to_string(static_cast<uint32_t>(
                          buf_info.buffer->GetBufferType())));
        break;
      }
    }

    if (buf_info.descriptor_set > kMaxDawnBindGroup - 1) {
      return Result(""AttachBuffers: Dawn has a maximum of "" +
                    std::to_string(kMaxDawnBindGroup) + "" (descriptor sets)"");
    }

    render_pipeline->buffers.emplace_back(
        CreateBufferFromData(*device_, buf_info.buffer->ValuePtr()->data(),
                             buf_info.buffer->GetMaxSizeInBytes(),
                             bufferUsage | ::dawn::BufferUsage::CopySrc |
                                 ::dawn::BufferUsage::CopyDst));

    render_pipeline->buffer_map[{buf_info.descriptor_set, buf_info.binding}] =
        render_pipeline->buffers.size() - 1;

    render_pipeline->used_descriptor_set.insert(buf_info.descriptor_set);
    max_descriptor_set = std::max(max_descriptor_set, buf_info.descriptor_set);

    ::dawn::BindGroupLayoutBinding layout_info;
    layout_info.binding = buf_info.binding;
    layout_info.visibility = kAllStages;
    layout_info.type = bindingType;
    layouts_info[buf_info.descriptor_set][buf_info.binding] = layout_info;

    BindingInitializationHelper tempBinding = BindingInitializationHelper(
        buf_info.binding, render_pipeline->buffers.back(), 0,
        buf_info.buffer->GetMaxSizeInBytes());
    bindingInitalizerHelper[buf_info.descriptor_set].push_back(tempBinding);
  }

  for (uint32_t i = 0; i < kMaxDawnBindGroup; i++) {
    if (layouts_info[i].size() > 0 && bindingInitalizerHelper[i].size() > 0) {
      ::dawn::BindGroupLayout bindGroupLayout =
          MakeBindGroupLayout(*device_, layouts_info[i]);
      render_pipeline->bind_group_layouts.push_back(bindGroupLayout);

      ::dawn::BindGroup bindGroup =
          MakeBindGroup(*device_, render_pipeline->bind_group_layouts[i],
                        bindingInitalizerHelper[i]);
      render_pipeline->bind_groups.push_back(bindGroup);
    } else if (i < max_descriptor_set) {
      ::dawn::BindGroupLayout bindGroupLayout =
          MakeBindGroupLayout(*device_, {});
      render_pipeline->bind_group_layouts.push_back(bindGroupLayout);

      ::dawn::BindGroup bindGroup =
          MakeBindGroup(*device_, render_pipeline->bind_group_layouts[i],
                        bindingInitalizerHelper[i]);
      render_pipeline->bind_groups.push_back(bindGroup);
    }
  }
  return {};
}

Result EngineDawn::AttachBuffers(ComputePipelineInfo* compute_pipeline) {
  Result result;

  // Do not attach pushConstants
  if (compute_pipeline->pipeline->GetPushConstantBuffer().buffer != nullptr) {
    return Result(""AttachBuffers: Dawn does not support push constants!"");
  }

  std::vector<std::vector<BindingInitializationHelper>> bindingInitalizerHelper(
      kMaxDawnBindGroup);
  std::vector<std::vector<::dawn::BindGroupLayoutBinding>> layouts_info(
      kMaxDawnBindGroup);
  uint32_t max_descriptor_set = 0;

  // Attach storage/uniform buffers
  ::dawn::BindGroupLayoutBinding empty_layout_info = {};

  if (!compute_pipeline->pipeline->GetBuffers().empty()) {
    std::vector<uint32_t> max_binding_seen(kMaxDawnBindGroup, -1);
    for (auto& buf_info : compute_pipeline->pipeline->GetBuffers()) {
      while (layouts_info[buf_info.descriptor_set].size() <= buf_info.binding)
        layouts_info[buf_info.descriptor_set].push_back(empty_layout_info);
    }
  }

  for (const auto& buf_info : compute_pipeline->pipeline->GetBuffers()) {
    ::dawn::BufferUsage bufferUsage;
    ::dawn::BindingType bindingType;
    switch (buf_info.buffer->GetBufferType()) {
      case BufferType::kStorage: {
        bufferUsage = ::dawn::BufferUsage::Storage;
        bindingType = ::dawn::BindingType::StorageBuffer;
        break;
      }
      case BufferType::kUniform: {
        bufferUsage = ::dawn::BufferUsage::Uniform;
        bindingType = ::dawn::BindingType::UniformBuffer;
        break;
      }
      default: {
        return Result(""AttachBuffers: unknown buffer type: "" +
                      std::to_string(static_cast<uint32_t>(
                          buf_info.buffer->GetBufferType())));
        break;
      }
    }

    if (buf_info.descriptor_set > kMaxDawnBindGroup - 1) {
      return Result(""AttachBuffers: Dawn has a maximum of "" +
                    std::to_string(kMaxDawnBindGroup) + "" (descriptor sets)"");
    }

    compute_pipeline->buffers.emplace_back(
        CreateBufferFromData(*device_, buf_info.buffer->ValuePtr()->data(),
                             buf_info.buffer->GetMaxSizeInBytes(),
                             bufferUsage | ::dawn::BufferUsage::CopySrc |
                                 ::dawn::BufferUsage::CopyDst));

    compute_pipeline->buffer_map[{buf_info.descriptor_set, buf_info.binding}] =
        compute_pipeline->buffers.size() - 1;

    compute_pipeline->used_descriptor_set.insert(buf_info.descriptor_set);
    max_descriptor_set = std::max(max_descriptor_set, buf_info.descriptor_set);

    ::dawn::BindGroupLayoutBinding layout_info;
    layout_info.binding = buf_info.binding;
    layout_info.visibility = ::dawn::ShaderStage::Compute;
    layout_info.type = bindingType;
    layouts_info[buf_info.descriptor_set][buf_info.binding] = layout_info;

    BindingInitializationHelper tempBinding = BindingInitializationHelper(
        buf_info.binding, compute_pipeline->buffers.back(), 0,
        buf_info.buffer->GetMaxSizeInBytes());
    bindingInitalizerHelper[buf_info.descriptor_set].push_back(tempBinding);
  }

  for (uint32_t i = 0; i < kMaxDawnBindGroup; i++) {
    if (layouts_info[i].size() > 0 && bindingInitalizerHelper[i].size() > 0) {
      ::dawn::BindGroupLayout bindGroupLayout =
          MakeBindGroupLayout(*device_, layouts_info[i]);
      compute_pipeline->bind_group_layouts.push_back(bindGroupLayout);

      ::dawn::BindGroup bindGroup =
          MakeBindGroup(*device_, compute_pipeline->bind_group_layouts[i],
                        bindingInitalizerHelper[i]);
      compute_pipeline->bind_groups.push_back(bindGroup);
    } else if (i < max_descriptor_set) {
      ::dawn::BindGroupLayout bindGroupLayout =
          MakeBindGroupLayout(*device_, {});
      compute_pipeline->bind_group_layouts.push_back(bindGroupLayout);

      ::dawn::BindGroup bindGroup =
          MakeBindGroup(*device_, compute_pipeline->bind_group_layouts[i],
                        bindingInitalizerHelper[i]);
      compute_pipeline->bind_groups.push_back(bindGroup);
    }
  }

  return {};
}

}  // namespace dawn
}  // namespace amber
",16374,True,2968.4896105207845,median
"// Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: camera/camera.proto

#include ""camera/camera.pb.h""
#include ""camera/camera.grpc.pb.h""

#include <functional>
#include <grpcpp/impl/codegen/async_stream.h>
#include <grpcpp/impl/codegen/async_unary_call.h>
#include <grpcpp/impl/codegen/channel_interface.h>
#include <grpcpp/impl/codegen/client_unary_call.h>
#include <grpcpp/impl/codegen/client_callback.h>
#include <grpcpp/impl/codegen/message_allocator.h>
#include <grpcpp/impl/codegen/method_handler.h>
#include <grpcpp/impl/codegen/rpc_service_method.h>
#include <grpcpp/impl/codegen/server_callback.h>
#include <grpcpp/impl/codegen/server_callback_handlers.h>
#include <grpcpp/impl/codegen/server_context.h>
#include <grpcpp/impl/codegen/service_type.h>
#include <grpcpp/impl/codegen/sync_stream.h>
namespace mavsdk {
namespace rpc {
namespace camera {

static const char* CameraService_method_names[] = {
  ""/mavsdk.rpc.camera.CameraService/TakePhoto"",
  ""/mavsdk.rpc.camera.CameraService/StartPhotoInterval"",
  ""/mavsdk.rpc.camera.CameraService/StopPhotoInterval"",
  ""/mavsdk.rpc.camera.CameraService/StartVideo"",
  ""/mavsdk.rpc.camera.CameraService/StopVideo"",
  ""/mavsdk.rpc.camera.CameraService/StartVideoStreaming"",
  ""/mavsdk.rpc.camera.CameraService/StopVideoStreaming"",
  ""/mavsdk.rpc.camera.CameraService/SetMode"",
  ""/mavsdk.rpc.camera.CameraService/ListPhotos"",
  ""/mavsdk.rpc.camera.CameraService/SubscribeMode"",
  ""/mavsdk.rpc.camera.CameraService/SubscribeInformation"",
  ""/mavsdk.rpc.camera.CameraService/SubscribeVideoStreamInfo"",
  ""/mavsdk.rpc.camera.CameraService/SubscribeCaptureInfo"",
  ""/mavsdk.rpc.camera.CameraService/SubscribeStatus"",
  ""/mavsdk.rpc.camera.CameraService/SubscribeCurrentSettings"",
  ""/mavsdk.rpc.camera.CameraService/SubscribePossibleSettingOptions"",
  ""/mavsdk.rpc.camera.CameraService/SetSetting"",
  ""/mavsdk.rpc.camera.CameraService/GetSetting"",
  ""/mavsdk.rpc.camera.CameraService/FormatStorage"",
};

std::unique_ptr< CameraService::Stub> CameraService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
  (void)options;
  std::unique_ptr< CameraService::Stub> stub(new CameraService::Stub(channel));
  return stub;
}

CameraService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
  : channel_(channel), rpcmethod_TakePhoto_(CameraService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StartPhotoInterval_(CameraService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StopPhotoInterval_(CameraService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StartVideo_(CameraService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StopVideo_(CameraService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StartVideoStreaming_(CameraService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StopVideoStreaming_(CameraService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SetMode_(CameraService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListPhotos_(CameraService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SubscribeMode_(CameraService_method_names[9], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SubscribeInformation_(CameraService_method_names[10], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SubscribeVideoStreamInfo_(CameraService_method_names[11], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SubscribeCaptureInfo_(CameraService_method_names[12], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SubscribeStatus_(CameraService_method_names[13], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SubscribeCurrentSettings_(CameraService_method_names[14], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SubscribePossibleSettingOptions_(CameraService_method_names[15], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SetSetting_(CameraService_method_names[16], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetSetting_(CameraService_method_names[17], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_FormatStorage_(CameraService_method_names[18], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status CameraService::Stub::TakePhoto(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::TakePhotoRequest& request, ::mavsdk::rpc::camera::TakePhotoResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::TakePhotoRequest, ::mavsdk::rpc::camera::TakePhotoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_TakePhoto_, context, request, response);
}

void CameraService::Stub::experimental_async::TakePhoto(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::TakePhotoRequest* request, ::mavsdk::rpc::camera::TakePhotoResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::TakePhotoRequest, ::mavsdk::rpc::camera::TakePhotoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_TakePhoto_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::TakePhoto(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::TakePhotoRequest* request, ::mavsdk::rpc::camera::TakePhotoResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_TakePhoto_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::TakePhotoResponse>* CameraService::Stub::PrepareAsyncTakePhotoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::TakePhotoRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::TakePhotoResponse, ::mavsdk::rpc::camera::TakePhotoRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_TakePhoto_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::TakePhotoResponse>* CameraService::Stub::AsyncTakePhotoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::TakePhotoRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncTakePhotoRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::StartPhotoInterval(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartPhotoIntervalRequest& request, ::mavsdk::rpc::camera::StartPhotoIntervalResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::StartPhotoIntervalRequest, ::mavsdk::rpc::camera::StartPhotoIntervalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartPhotoInterval_, context, request, response);
}

void CameraService::Stub::experimental_async::StartPhotoInterval(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartPhotoIntervalRequest* request, ::mavsdk::rpc::camera::StartPhotoIntervalResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::StartPhotoIntervalRequest, ::mavsdk::rpc::camera::StartPhotoIntervalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartPhotoInterval_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::StartPhotoInterval(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartPhotoIntervalRequest* request, ::mavsdk::rpc::camera::StartPhotoIntervalResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartPhotoInterval_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StartPhotoIntervalResponse>* CameraService::Stub::PrepareAsyncStartPhotoIntervalRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartPhotoIntervalRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::StartPhotoIntervalResponse, ::mavsdk::rpc::camera::StartPhotoIntervalRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartPhotoInterval_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StartPhotoIntervalResponse>* CameraService::Stub::AsyncStartPhotoIntervalRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartPhotoIntervalRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStartPhotoIntervalRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::StopPhotoInterval(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopPhotoIntervalRequest& request, ::mavsdk::rpc::camera::StopPhotoIntervalResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::StopPhotoIntervalRequest, ::mavsdk::rpc::camera::StopPhotoIntervalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StopPhotoInterval_, context, request, response);
}

void CameraService::Stub::experimental_async::StopPhotoInterval(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopPhotoIntervalRequest* request, ::mavsdk::rpc::camera::StopPhotoIntervalResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::StopPhotoIntervalRequest, ::mavsdk::rpc::camera::StopPhotoIntervalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopPhotoInterval_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::StopPhotoInterval(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopPhotoIntervalRequest* request, ::mavsdk::rpc::camera::StopPhotoIntervalResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopPhotoInterval_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StopPhotoIntervalResponse>* CameraService::Stub::PrepareAsyncStopPhotoIntervalRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopPhotoIntervalRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::StopPhotoIntervalResponse, ::mavsdk::rpc::camera::StopPhotoIntervalRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StopPhotoInterval_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StopPhotoIntervalResponse>* CameraService::Stub::AsyncStopPhotoIntervalRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopPhotoIntervalRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStopPhotoIntervalRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::StartVideo(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoRequest& request, ::mavsdk::rpc::camera::StartVideoResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::StartVideoRequest, ::mavsdk::rpc::camera::StartVideoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartVideo_, context, request, response);
}

void CameraService::Stub::experimental_async::StartVideo(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoRequest* request, ::mavsdk::rpc::camera::StartVideoResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::StartVideoRequest, ::mavsdk::rpc::camera::StartVideoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartVideo_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::StartVideo(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoRequest* request, ::mavsdk::rpc::camera::StartVideoResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartVideo_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StartVideoResponse>* CameraService::Stub::PrepareAsyncStartVideoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::StartVideoResponse, ::mavsdk::rpc::camera::StartVideoRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartVideo_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StartVideoResponse>* CameraService::Stub::AsyncStartVideoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStartVideoRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::StopVideo(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoRequest& request, ::mavsdk::rpc::camera::StopVideoResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::StopVideoRequest, ::mavsdk::rpc::camera::StopVideoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StopVideo_, context, request, response);
}

void CameraService::Stub::experimental_async::StopVideo(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoRequest* request, ::mavsdk::rpc::camera::StopVideoResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::StopVideoRequest, ::mavsdk::rpc::camera::StopVideoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopVideo_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::StopVideo(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoRequest* request, ::mavsdk::rpc::camera::StopVideoResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopVideo_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StopVideoResponse>* CameraService::Stub::PrepareAsyncStopVideoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::StopVideoResponse, ::mavsdk::rpc::camera::StopVideoRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StopVideo_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StopVideoResponse>* CameraService::Stub::AsyncStopVideoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStopVideoRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::StartVideoStreaming(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoStreamingRequest& request, ::mavsdk::rpc::camera::StartVideoStreamingResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::StartVideoStreamingRequest, ::mavsdk::rpc::camera::StartVideoStreamingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartVideoStreaming_, context, request, response);
}

void CameraService::Stub::experimental_async::StartVideoStreaming(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoStreamingRequest* request, ::mavsdk::rpc::camera::StartVideoStreamingResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::StartVideoStreamingRequest, ::mavsdk::rpc::camera::StartVideoStreamingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartVideoStreaming_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::StartVideoStreaming(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoStreamingRequest* request, ::mavsdk::rpc::camera::StartVideoStreamingResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartVideoStreaming_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StartVideoStreamingResponse>* CameraService::Stub::PrepareAsyncStartVideoStreamingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoStreamingRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::StartVideoStreamingResponse, ::mavsdk::rpc::camera::StartVideoStreamingRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartVideoStreaming_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StartVideoStreamingResponse>* CameraService::Stub::AsyncStartVideoStreamingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StartVideoStreamingRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStartVideoStreamingRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::StopVideoStreaming(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoStreamingRequest& request, ::mavsdk::rpc::camera::StopVideoStreamingResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::StopVideoStreamingRequest, ::mavsdk::rpc::camera::StopVideoStreamingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StopVideoStreaming_, context, request, response);
}

void CameraService::Stub::experimental_async::StopVideoStreaming(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoStreamingRequest* request, ::mavsdk::rpc::camera::StopVideoStreamingResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::StopVideoStreamingRequest, ::mavsdk::rpc::camera::StopVideoStreamingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopVideoStreaming_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::StopVideoStreaming(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoStreamingRequest* request, ::mavsdk::rpc::camera::StopVideoStreamingResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopVideoStreaming_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StopVideoStreamingResponse>* CameraService::Stub::PrepareAsyncStopVideoStreamingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoStreamingRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::StopVideoStreamingResponse, ::mavsdk::rpc::camera::StopVideoStreamingRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StopVideoStreaming_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::StopVideoStreamingResponse>* CameraService::Stub::AsyncStopVideoStreamingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::StopVideoStreamingRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStopVideoStreamingRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::SetMode(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetModeRequest& request, ::mavsdk::rpc::camera::SetModeResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::SetModeRequest, ::mavsdk::rpc::camera::SetModeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetMode_, context, request, response);
}

void CameraService::Stub::experimental_async::SetMode(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetModeRequest* request, ::mavsdk::rpc::camera::SetModeResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::SetModeRequest, ::mavsdk::rpc::camera::SetModeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetMode_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::SetMode(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetModeRequest* request, ::mavsdk::rpc::camera::SetModeResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetMode_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::SetModeResponse>* CameraService::Stub::PrepareAsyncSetModeRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetModeRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::SetModeResponse, ::mavsdk::rpc::camera::SetModeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetMode_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::SetModeResponse>* CameraService::Stub::AsyncSetModeRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetModeRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSetModeRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::ListPhotos(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::ListPhotosRequest& request, ::mavsdk::rpc::camera::ListPhotosResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::ListPhotosRequest, ::mavsdk::rpc::camera::ListPhotosResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ListPhotos_, context, request, response);
}

void CameraService::Stub::experimental_async::ListPhotos(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::ListPhotosRequest* request, ::mavsdk::rpc::camera::ListPhotosResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::ListPhotosRequest, ::mavsdk::rpc::camera::ListPhotosResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListPhotos_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::ListPhotos(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::ListPhotosRequest* request, ::mavsdk::rpc::camera::ListPhotosResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListPhotos_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::ListPhotosResponse>* CameraService::Stub::PrepareAsyncListPhotosRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::ListPhotosRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::ListPhotosResponse, ::mavsdk::rpc::camera::ListPhotosRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ListPhotos_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::ListPhotosResponse>* CameraService::Stub::AsyncListPhotosRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::ListPhotosRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncListPhotosRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::mavsdk::rpc::camera::ModeResponse>* CameraService::Stub::SubscribeModeRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeModeRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::ModeResponse>::Create(channel_.get(), rpcmethod_SubscribeMode_, context, request);
}

void CameraService::Stub::experimental_async::SubscribeMode(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribeModeRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::ModeResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::ModeResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeMode_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::ModeResponse>* CameraService::Stub::AsyncSubscribeModeRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeModeRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::ModeResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeMode_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::ModeResponse>* CameraService::Stub::PrepareAsyncSubscribeModeRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeModeRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::ModeResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeMode_, context, request, false, nullptr);
}

::grpc::ClientReader< ::mavsdk::rpc::camera::InformationResponse>* CameraService::Stub::SubscribeInformationRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeInformationRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::InformationResponse>::Create(channel_.get(), rpcmethod_SubscribeInformation_, context, request);
}

void CameraService::Stub::experimental_async::SubscribeInformation(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribeInformationRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::InformationResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::InformationResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeInformation_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::InformationResponse>* CameraService::Stub::AsyncSubscribeInformationRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeInformationRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::InformationResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeInformation_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::InformationResponse>* CameraService::Stub::PrepareAsyncSubscribeInformationRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeInformationRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::InformationResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeInformation_, context, request, false, nullptr);
}

::grpc::ClientReader< ::mavsdk::rpc::camera::VideoStreamInfoResponse>* CameraService::Stub::SubscribeVideoStreamInfoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::VideoStreamInfoResponse>::Create(channel_.get(), rpcmethod_SubscribeVideoStreamInfo_, context, request);
}

void CameraService::Stub::experimental_async::SubscribeVideoStreamInfo(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::VideoStreamInfoResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::VideoStreamInfoResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeVideoStreamInfo_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::VideoStreamInfoResponse>* CameraService::Stub::AsyncSubscribeVideoStreamInfoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::VideoStreamInfoResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeVideoStreamInfo_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::VideoStreamInfoResponse>* CameraService::Stub::PrepareAsyncSubscribeVideoStreamInfoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::VideoStreamInfoResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeVideoStreamInfo_, context, request, false, nullptr);
}

::grpc::ClientReader< ::mavsdk::rpc::camera::CaptureInfoResponse>* CameraService::Stub::SubscribeCaptureInfoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::CaptureInfoResponse>::Create(channel_.get(), rpcmethod_SubscribeCaptureInfo_, context, request);
}

void CameraService::Stub::experimental_async::SubscribeCaptureInfo(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::CaptureInfoResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::CaptureInfoResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeCaptureInfo_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::CaptureInfoResponse>* CameraService::Stub::AsyncSubscribeCaptureInfoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::CaptureInfoResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeCaptureInfo_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::CaptureInfoResponse>* CameraService::Stub::PrepareAsyncSubscribeCaptureInfoRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::CaptureInfoResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeCaptureInfo_, context, request, false, nullptr);
}

::grpc::ClientReader< ::mavsdk::rpc::camera::StatusResponse>* CameraService::Stub::SubscribeStatusRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeStatusRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::StatusResponse>::Create(channel_.get(), rpcmethod_SubscribeStatus_, context, request);
}

void CameraService::Stub::experimental_async::SubscribeStatus(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribeStatusRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::StatusResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::StatusResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeStatus_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::StatusResponse>* CameraService::Stub::AsyncSubscribeStatusRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeStatusRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::StatusResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeStatus_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::StatusResponse>* CameraService::Stub::PrepareAsyncSubscribeStatusRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeStatusRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::StatusResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeStatus_, context, request, false, nullptr);
}

::grpc::ClientReader< ::mavsdk::rpc::camera::CurrentSettingsResponse>* CameraService::Stub::SubscribeCurrentSettingsRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::CurrentSettingsResponse>::Create(channel_.get(), rpcmethod_SubscribeCurrentSettings_, context, request);
}

void CameraService::Stub::experimental_async::SubscribeCurrentSettings(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::CurrentSettingsResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::CurrentSettingsResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribeCurrentSettings_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::CurrentSettingsResponse>* CameraService::Stub::AsyncSubscribeCurrentSettingsRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::CurrentSettingsResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeCurrentSettings_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::CurrentSettingsResponse>* CameraService::Stub::PrepareAsyncSubscribeCurrentSettingsRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::CurrentSettingsResponse>::Create(channel_.get(), cq, rpcmethod_SubscribeCurrentSettings_, context, request, false, nullptr);
}

::grpc::ClientReader< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>* CameraService::Stub::SubscribePossibleSettingOptionsRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>::Create(channel_.get(), rpcmethod_SubscribePossibleSettingOptions_, context, request);
}

void CameraService::Stub::experimental_async::SubscribePossibleSettingOptions(::grpc::ClientContext* context, ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest* request, ::grpc::experimental::ClientReadReactor< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_SubscribePossibleSettingOptions_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>* CameraService::Stub::AsyncSubscribePossibleSettingOptionsRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>::Create(channel_.get(), cq, rpcmethod_SubscribePossibleSettingOptions_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>* CameraService::Stub::PrepareAsyncSubscribePossibleSettingOptionsRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>::Create(channel_.get(), cq, rpcmethod_SubscribePossibleSettingOptions_, context, request, false, nullptr);
}

::grpc::Status CameraService::Stub::SetSetting(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetSettingRequest& request, ::mavsdk::rpc::camera::SetSettingResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::SetSettingRequest, ::mavsdk::rpc::camera::SetSettingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetSetting_, context, request, response);
}

void CameraService::Stub::experimental_async::SetSetting(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetSettingRequest* request, ::mavsdk::rpc::camera::SetSettingResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::SetSettingRequest, ::mavsdk::rpc::camera::SetSettingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetSetting_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::SetSetting(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetSettingRequest* request, ::mavsdk::rpc::camera::SetSettingResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetSetting_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::SetSettingResponse>* CameraService::Stub::PrepareAsyncSetSettingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetSettingRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::SetSettingResponse, ::mavsdk::rpc::camera::SetSettingRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetSetting_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::SetSettingResponse>* CameraService::Stub::AsyncSetSettingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::SetSettingRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSetSettingRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::GetSetting(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::GetSettingRequest& request, ::mavsdk::rpc::camera::GetSettingResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::GetSettingRequest, ::mavsdk::rpc::camera::GetSettingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetSetting_, context, request, response);
}

void CameraService::Stub::experimental_async::GetSetting(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::GetSettingRequest* request, ::mavsdk::rpc::camera::GetSettingResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::GetSettingRequest, ::mavsdk::rpc::camera::GetSettingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSetting_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::GetSetting(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::GetSettingRequest* request, ::mavsdk::rpc::camera::GetSettingResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSetting_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::GetSettingResponse>* CameraService::Stub::PrepareAsyncGetSettingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::GetSettingRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::GetSettingResponse, ::mavsdk::rpc::camera::GetSettingRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetSetting_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::GetSettingResponse>* CameraService::Stub::AsyncGetSettingRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::GetSettingRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetSettingRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CameraService::Stub::FormatStorage(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::FormatStorageRequest& request, ::mavsdk::rpc::camera::FormatStorageResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::mavsdk::rpc::camera::FormatStorageRequest, ::mavsdk::rpc::camera::FormatStorageResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_FormatStorage_, context, request, response);
}

void CameraService::Stub::experimental_async::FormatStorage(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::FormatStorageRequest* request, ::mavsdk::rpc::camera::FormatStorageResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::mavsdk::rpc::camera::FormatStorageRequest, ::mavsdk::rpc::camera::FormatStorageResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FormatStorage_, context, request, response, std::move(f));
}

void CameraService::Stub::experimental_async::FormatStorage(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::FormatStorageRequest* request, ::mavsdk::rpc::camera::FormatStorageResponse* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_FormatStorage_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::FormatStorageResponse>* CameraService::Stub::PrepareAsyncFormatStorageRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::FormatStorageRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::mavsdk::rpc::camera::FormatStorageResponse, ::mavsdk::rpc::camera::FormatStorageRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_FormatStorage_, context, request);
}

::grpc::ClientAsyncResponseReader< ::mavsdk::rpc::camera::FormatStorageResponse>* CameraService::Stub::AsyncFormatStorageRaw(::grpc::ClientContext* context, const ::mavsdk::rpc::camera::FormatStorageRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncFormatStorageRaw(context, request, cq);
  result->StartCall();
  return result;
}

CameraService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::TakePhotoRequest, ::mavsdk::rpc::camera::TakePhotoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::TakePhotoRequest* req,
             ::mavsdk::rpc::camera::TakePhotoResponse* resp) {
               return service->TakePhoto(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::StartPhotoIntervalRequest, ::mavsdk::rpc::camera::StartPhotoIntervalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::StartPhotoIntervalRequest* req,
             ::mavsdk::rpc::camera::StartPhotoIntervalResponse* resp) {
               return service->StartPhotoInterval(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[2],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::StopPhotoIntervalRequest, ::mavsdk::rpc::camera::StopPhotoIntervalResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::StopPhotoIntervalRequest* req,
             ::mavsdk::rpc::camera::StopPhotoIntervalResponse* resp) {
               return service->StopPhotoInterval(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[3],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::StartVideoRequest, ::mavsdk::rpc::camera::StartVideoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::StartVideoRequest* req,
             ::mavsdk::rpc::camera::StartVideoResponse* resp) {
               return service->StartVideo(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[4],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::StopVideoRequest, ::mavsdk::rpc::camera::StopVideoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::StopVideoRequest* req,
             ::mavsdk::rpc::camera::StopVideoResponse* resp) {
               return service->StopVideo(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[5],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::StartVideoStreamingRequest, ::mavsdk::rpc::camera::StartVideoStreamingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::StartVideoStreamingRequest* req,
             ::mavsdk::rpc::camera::StartVideoStreamingResponse* resp) {
               return service->StartVideoStreaming(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[6],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::StopVideoStreamingRequest, ::mavsdk::rpc::camera::StopVideoStreamingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::StopVideoStreamingRequest* req,
             ::mavsdk::rpc::camera::StopVideoStreamingResponse* resp) {
               return service->StopVideoStreaming(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[7],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::SetModeRequest, ::mavsdk::rpc::camera::SetModeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SetModeRequest* req,
             ::mavsdk::rpc::camera::SetModeResponse* resp) {
               return service->SetMode(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[8],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::ListPhotosRequest, ::mavsdk::rpc::camera::ListPhotosResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::ListPhotosRequest* req,
             ::mavsdk::rpc::camera::ListPhotosResponse* resp) {
               return service->ListPhotos(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[9],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribeModeRequest, ::mavsdk::rpc::camera::ModeResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribeModeRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::ModeResponse>* writer) {
               return service->SubscribeMode(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[10],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribeInformationRequest, ::mavsdk::rpc::camera::InformationResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribeInformationRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::InformationResponse>* writer) {
               return service->SubscribeInformation(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[11],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest, ::mavsdk::rpc::camera::VideoStreamInfoResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::VideoStreamInfoResponse>* writer) {
               return service->SubscribeVideoStreamInfo(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[12],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest, ::mavsdk::rpc::camera::CaptureInfoResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::CaptureInfoResponse>* writer) {
               return service->SubscribeCaptureInfo(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[13],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribeStatusRequest, ::mavsdk::rpc::camera::StatusResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribeStatusRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::StatusResponse>* writer) {
               return service->SubscribeStatus(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[14],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest, ::mavsdk::rpc::camera::CurrentSettingsResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::CurrentSettingsResponse>* writer) {
               return service->SubscribeCurrentSettings(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[15],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< CameraService::Service, ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest, ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest* req,
             ::grpc::ServerWriter<::mavsdk::rpc::camera::PossibleSettingOptionsResponse>* writer) {
               return service->SubscribePossibleSettingOptions(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[16],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::SetSettingRequest, ::mavsdk::rpc::camera::SetSettingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::SetSettingRequest* req,
             ::mavsdk::rpc::camera::SetSettingResponse* resp) {
               return service->SetSetting(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[17],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::GetSettingRequest, ::mavsdk::rpc::camera::GetSettingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::GetSettingRequest* req,
             ::mavsdk::rpc::camera::GetSettingResponse* resp) {
               return service->GetSetting(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CameraService_method_names[18],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CameraService::Service, ::mavsdk::rpc::camera::FormatStorageRequest, ::mavsdk::rpc::camera::FormatStorageResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CameraService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::mavsdk::rpc::camera::FormatStorageRequest* req,
             ::mavsdk::rpc::camera::FormatStorageResponse* resp) {
               return service->FormatStorage(ctx, req, resp);
             }, this)));
}

CameraService::Service::~Service() {
}

::grpc::Status CameraService::Service::TakePhoto(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::TakePhotoRequest* request, ::mavsdk::rpc::camera::TakePhotoResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::StartPhotoInterval(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::StartPhotoIntervalRequest* request, ::mavsdk::rpc::camera::StartPhotoIntervalResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::StopPhotoInterval(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::StopPhotoIntervalRequest* request, ::mavsdk::rpc::camera::StopPhotoIntervalResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::StartVideo(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::StartVideoRequest* request, ::mavsdk::rpc::camera::StartVideoResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::StopVideo(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::StopVideoRequest* request, ::mavsdk::rpc::camera::StopVideoResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::StartVideoStreaming(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::StartVideoStreamingRequest* request, ::mavsdk::rpc::camera::StartVideoStreamingResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::StopVideoStreaming(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::StopVideoStreamingRequest* request, ::mavsdk::rpc::camera::StopVideoStreamingResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SetMode(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SetModeRequest* request, ::mavsdk::rpc::camera::SetModeResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::ListPhotos(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::ListPhotosRequest* request, ::mavsdk::rpc::camera::ListPhotosResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribeMode(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribeModeRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::ModeResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribeInformation(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribeInformationRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::InformationResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribeVideoStreamInfo(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribeVideoStreamInfoRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::VideoStreamInfoResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribeCaptureInfo(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribeCaptureInfoRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::CaptureInfoResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribeStatus(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribeStatusRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::StatusResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribeCurrentSettings(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribeCurrentSettingsRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::CurrentSettingsResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SubscribePossibleSettingOptions(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SubscribePossibleSettingOptionsRequest* request, ::grpc::ServerWriter< ::mavsdk::rpc::camera::PossibleSettingOptionsResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::SetSetting(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::SetSettingRequest* request, ::mavsdk::rpc::camera::SetSettingResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::GetSetting(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::GetSettingRequest* request, ::mavsdk::rpc::camera::GetSettingResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}

::grpc::Status CameraService::Service::FormatStorage(::grpc::ServerContext* context, const ::mavsdk::rpc::camera::FormatStorageRequest* request, ::mavsdk::rpc::camera::FormatStorageResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, """");
}


}  // namespace mavsdk
}  // namespace rpc
}  // namespace camera

",16232,True,4915.320376545036,median
"[[debezium-postgres-component]]
= Debezium PostgresSQL Connector Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-debezium/camel-debezium-postgres/src/main/docs/debezium-postgres-component.adoc
:docTitle: Debezium PostgresSQL Connector
:artifactId: camel-debezium-postgres
:description: Capture changes from a PostgresSQL database.
:since: 3.0
:supportLevel: Stable
:component-header: Only consumer is supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/debezium-postgres.adoc[opts=optional]
//Manually maintained attributes
:group: Debezium

*Since Camel {since}*

*{component-header}*


The Debezium PostgresSQL component is wrapper around https://debezium.io/[Debezium] using https://debezium.io/documentation/reference/0.9/operations/embedded.html[Debezium Embedded], which enables Change Data Capture from PostgresSQL database using Debezium without the need for Kafka or Kafka Connect.

*Note on handling failures:* Per https://debezium.io/documentation/reference/0.9/operations/embedded.html#_handling_failures[Debezium Embedded Engine] documentation, the engines is actively recording source offsets and periodically flushes these offsets to a persistent storage, so when the application is restarted or crashed, the engine will resume from the last recorded offset.
Thus, at normal operation, your downstream routes will receive each event exactly once, however in case of an application crash (not having a graceful shutdown), the application will resume from the last recorded offset,
which may result in receiving duplicate events immediately after the restart. Therefore, your downstream routes should be tolerant enough of such case and deduplicate events if needed.

*Note:* The Debezium PostgresSQL component is currently not supported in OSGi

Maven users will need to add the following dependency to their `pom.xml`
for this component.

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-debezium-postgres</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

---------------------------
debezium-postgres:name[?options]
---------------------------


// component-configure options: START
== Configuring Options

Camel components are configured on two separate levels:

- component level
- endpoint level

=== Configuring Component Options

The component level is the highest level which holds general and common configurations that are inherited by the endpoints.
For example a component may have security settings, credentials for authentication, urls for network connection and so forth.

Some components only have a few options, and others may have many. Because components typically have pre configured defaults
that are commonly used, then you may often only need to configure a few options on a component; or none at all.

Configuring components can be done with the xref:latest@manual::component-dsl.adoc[Component DSL],
in a configuration file (application.properties|yaml), or directly with Java code.

=== Configuring Endpoint Options

Where you find yourself configuring the most is on endpoints, as endpoints often have many options, which allows you to
configure what you need the endpoint to do. The options are also categorized into whether the endpoint is used as consumer (from)
or as a producer (to), or used for both.

Configuring endpoints is most often done directly in the endpoint URI as path and query parameters. You can also use
the xref:latest@manual::Endpoint-dsl.adoc[Endpoint DSL] as a _type safe_ way of configuring endpoints.

A good practice when configuring options is to use xref:latest@manual::using-propertyplaceholder.adoc[Property Placeholders],
which allows to not hardcode urls, port numbers, sensitive information, and other settings.
In other words placeholders allows to externalize the configuration from your code, and gives more flexibility and reuse.

The following two sections lists all the options, firstly for the component followed by the endpoint.
// component-configure options: END

// component options: START
== Component Options


The Debezium PostgresSQL Connector component supports 89 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *additionalProperties* (common) | Additional properties for debezium components in case they can't be set directly on the camel configurations (e.g: setting Kafka Connect properties needed by Debezium engine, for example setting KafkaOffsetBackingStore), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro |  | Map
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *configuration* (consumer) | Allow pre-configured Configurations to be set. |  | PostgresConnectorEmbeddedDebeziumConfiguration
| *internalKeyConverter* (consumer) | The Converter class that should be used to serialize and deserialize key data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *internalValueConverter* (consumer) | The Converter class that should be used to serialize and deserialize value data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *offsetCommitPolicy* (consumer) | The name of the Java class of the commit policy. It defines when offsets commit has to be triggered based on the number of events processed and the time elapsed since the last commit. This class must implement the interface 'OffsetCommitPolicy'. The default is a periodic commit policy based upon time intervals. | io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy | String
| *offsetCommitTimeoutMs* (consumer) | Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt. The default is 5 seconds. | 5s | long
| *offsetFlushIntervalMs* (consumer) | Interval at which to try committing offsets. The default is 1 minute. | 60s | long
| *offsetStorage* (consumer) | The name of the Java class that is responsible for persistence of connector offsets. | org.apache.kafka.connect.storage.FileOffsetBackingStore | String
| *offsetStorageFileName* (consumer) | Path to file where offsets are to be stored. Required when offset.storage is set to the FileOffsetBackingStore. |  | String
| *offsetStoragePartitions* (consumer) | The number of partitions used when creating the offset storage topic. Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |  | int
| *offsetStorageReplicationFactor* (consumer) | Replication factor used when creating the offset storage topic. Required when offset.storage is set to the KafkaOffsetBackingStore |  | int
| *offsetStorageTopic* (consumer) | The name of the Kafka topic where offsets are to be stored. Required when offset.storage is set to the KafkaOffsetBackingStore. |  | String
| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
| *binaryHandlingMode* (postgres) | Specify how binary (blob, binary, etc.) columns should be represented in change events, including:'bytes' represents binary data as byte array (default)'base64' represents binary data as base64-encoded string'hex' represents binary data as hex-encoded (base16) string | bytes | String
| *columnBlacklist* (postgres) | Regular expressions matching columns to exclude from change events (deprecated, use column.exclude.list instead) |  | String
| *columnExcludeList* (postgres) | Regular expressions matching columns to exclude from change events |  | String
| *columnIncludeList* (postgres) | Regular expressions matching columns to include in change events |  | String
| *columnPropagateSourceType* (postgres) | A comma-separated list of regular expressions matching fully-qualified names of columns that adds the columns original type and original length as parameters to the corresponding field schemas in the emitted change records. |  | String
| *columnWhitelist* (postgres) | Regular expressions matching columns to include in change events (deprecated, use column.include.list instead) |  | String
| *converters* (postgres) | Optional list of custom converters that would be used instead of default ones. The converters are defined using '.type' config option and configured using options '.' |  | String
| *databaseDbname* (postgres) | The name of the database the connector should be monitoring |  | String
| *databaseHistoryFileFilename* (postgres) | The path to the file that will be used to record the database history |  | String
| *databaseHostname* (postgres) | Resolvable hostname or IP address of the database server. |  | String
| *databaseInitialStatements* (postgres) | A semicolon separated list of SQL statements to be executed when a JDBC connection to the database is established. Note that the connector may establish JDBC connections at its own discretion, so this should typically be used for configurationof session parameters only, but not for executing DML statements. Use doubled semicolon (';;') to use a semicolon as a character and not as a delimiter. |  | String
| *databasePassword* (postgres) | *Required* Password of the database user to be used when connecting to the database. |  | String
| *databasePort* (postgres) | Port of the database server. | 5432 | int
| *databaseServerName* (postgres) | *Required* Unique name that identifies the database server and all recorded offsets, and that is used as a prefix for all schemas and topics. Each distinct installation should have a separate namespace and be monitored by at most one Debezium connector. |  | String
| *databaseSslcert* (postgres) | File containing the SSL Certificate for the client. See the Postgres SSL docs for further information |  | String
| *databaseSslfactory* (postgres) | A name of class to that creates SSL Sockets. Use org.postgresql.ssl.NonValidatingFactory to disable SSL validation in development environments |  | String
| *databaseSslkey* (postgres) | File containing the SSL private key for the client. See the Postgres SSL docs for further information |  | String
| *databaseSslmode* (postgres) | Whether to use an encrypted connection to Postgres. Options include'disable' (the default) to use an unencrypted connection; 'require' to use a secure (encrypted) connection, and fail if one cannot be established; 'verify-ca' like 'required' but additionally verify the server TLS certificate against the configured Certificate Authority (CA) certificates, or fail if no valid matching CA certificates are found; or'verify-full' like 'verify-ca' but additionally verify that the server certificate matches the host to which the connection is attempted. | disable | String
| *databaseSslpassword* (postgres) | Password to access the client private key from the file specified by 'database.sslkey'. See the Postgres SSL docs for further information |  | String
| *databaseSslrootcert* (postgres) | File containing the root certificate(s) against which the server is validated. See the Postgres JDBC SSL docs for further information |  | String
| *databaseTcpkeepalive* (postgres) | Enable or disable TCP keep-alive probe to avoid dropping TCP connection | true | boolean
| *databaseUser* (postgres) | Name of the database user to be used when connecting to the database. |  | String
| *datatypePropagateSourceType* (postgres) | A comma-separated list of regular expressions matching the database-specific data type names that adds the data type's original type and original length as parameters to the corresponding field schemas in the emitted change records. |  | String
| *decimalHandlingMode* (postgres) | Specify how DECIMAL and NUMERIC columns should be represented in change events, including:'precise' (the default) uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to represent values; 'double' represents values using Java's 'double', which may not offer the precision but will be far easier to use in consumers. | precise | String
| *eventProcessingFailureHandling{zwsp}Mode* (postgres) | Specify how failures during processing of events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its position is raised, causing the connector to be stopped; 'warn' the problematic event and its position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *heartbeatActionQuery* (postgres) | The query executed with every heartbeat. |  | String
| *heartbeatIntervalMs* (postgres) | Length of an interval in milli-seconds in in which the connector periodically sends heartbeat messages to a heartbeat topic. Use 0 to disable heartbeat messages. Disabled by default. | 0ms | int
| *heartbeatTopicsPrefix* (postgres) | The prefix that is used to name heartbeat topics.Defaults to __debezium-heartbeat. | __debezium-heartbeat | String
| *hstoreHandlingMode* (postgres) | Specify how HSTORE columns should be represented in change events, including:'json' represents values as string-ified JSON (default)'map' represents values as a key/value map | json | String
| *includeUnknownDatatypes* (postgres) | Specify whether the fields of data type not supported by Debezium should be processed:'false' (the default) omits the fields; 'true' converts the field into an implementation dependent binary representation. | false | boolean
| *incrementalSnapshotChunkSize* (postgres) | The maximum size of chunk for incremental snapshotting | 1024 | int
| *intervalHandlingMode* (postgres) | Specify how INTERVAL columns should be represented in change events, including:'string' represents values as an exact ISO formatted string'numeric' (default) represents values using the inexact conversion into microseconds | numeric | String
| *maxBatchSize* (postgres) | Maximum size of each batch of source records. Defaults to 2048. | 2048 | int
| *maxQueueSize* (postgres) | Maximum size of the queue for change events read from the database log but not yet recorded or forwarded. Defaults to 8192, and should always be larger than the maximum batch size. | 8192 | int
| *maxQueueSizeInBytes* (postgres) | Maximum size of the queue in bytes for change events read from the database log but not yet recorded or forwarded. Defaults to 0. Mean the feature is not enabled | 0 | long
| *messageKeyColumns* (postgres) | A semicolon-separated list of expressions that match fully-qualified tables and column(s) to be used as message key. Each expression must match the pattern ':',where the table names could be defined as (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the specific connector,and the key columns are a comma-separated list of columns representing the custom key. For any table without an explicit key configuration the table's primary key column(s) will be used as message key.Example: dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |  | String
| *pluginName* (postgres) | The name of the Postgres logical decoding plugin installed on the server. Supported values are 'decoderbufs', 'wal2json', 'pgoutput', 'wal2json_streaming', 'wal2json_rds' and 'wal2json_rds_streaming'. Defaults to 'decoderbufs'. | decoderbufs | String
| *pollIntervalMs* (postgres) | Time to wait for new change events to appear after receiving no events, given in milliseconds. Defaults to 500 ms. | 500ms | long
| *provideTransactionMetadata* (postgres) | Enables transaction metadata extraction together with event counting | false | boolean
| *publicationAutocreateMode* (postgres) | Applies only when streaming changes using pgoutput.Determine how creation of a publication should work, the default is all_tables.DISABLED - The connector will not attempt to create a publication at all. The expectation is that the user has created the publication up-front. If the publication isn't found to exist upon startup, the connector will throw an exception and stop.ALL_TABLES - If no publication exists, the connector will create a new publication for all tables. Note this requires that the configured user has access. If the publication already exists, it will be used. i.e CREATE PUBLICATION FOR ALL TABLES;FILTERED - If no publication exists, the connector will create a new publication for all those tables matchingthe current filter configuration (see table/database include/exclude list properties). If the publication already exists, it will be used. i.e CREATE PUBLICATION FOR TABLE | all_tables | String
| *publicationName* (postgres) | The name of the Postgres 10 publication used for streaming changes from a plugin.Defaults to 'dbz_publication' | dbz_publication | String
| *queryFetchSize* (postgres) | The maximum number of records that should be loaded into memory while streaming. A value of 0 uses the default JDBC fetch size. | 0 | int
| *retriableRestartConnectorWait{zwsp}Ms* (postgres) | Time to wait before restarting connector after retriable exception occurs. Defaults to 10000ms. | 10s | long
| *sanitizeFieldNames* (postgres) | Whether field names will be sanitized to Avro naming conventions | false | boolean
| *schemaBlacklist* (postgres) | The schemas for which events must not be captured (deprecated, use schema.exclude.list instead) |  | String
| *schemaExcludeList* (postgres) | The schemas for which events must not be captured |  | String
| *schemaIncludeList* (postgres) | The schemas for which events should be captured |  | String
| *schemaRefreshMode* (postgres) | Specify the conditions that trigger a refresh of the in-memory schema for a table. 'columns_diff' (the default) is the safest mode, ensuring the in-memory schema stays in-sync with the database table's schema at all times. 'columns_diff_exclude_unchanged_toast' instructs the connector to refresh the in-memory schema cache if there is a discrepancy between it and the schema derived from the incoming message, unless unchanged TOASTable data fully accounts for the discrepancy. This setting can improve connector performance significantly if there are frequently-updated tables that have TOASTed data that are rarely part of these updates. However, it is possible for the in-memory schema to become outdated if TOASTable columns are dropped from the table. | columns_diff | String
| *schemaWhitelist* (postgres) | The schemas for which events should be captured (deprecated, use schema.include.list instead) |  | String
| *signalDataCollection* (postgres) | The name of the data collection that is used to send signals/commands to Debezium. Signaling is disabled when not set. |  | String
| *skippedOperations* (postgres) | The comma-separated list of operations to skip during streaming, defined as: 'c' for inserts/create; 'u' for updates; 'd' for deletes. By default, no operations will be skipped. |  | String
| *slotDropOnStop* (postgres) | Whether or not to drop the logical replication slot when the connector finishes orderlyBy default the replication is kept so that on restart progress can resume from the last recorded location | false | boolean
| *slotMaxRetries* (postgres) | How many times to retry connecting to a replication slot when an attempt fails. | 6 | int
| *slotName* (postgres) | The name of the Postgres logical decoding slot created for streaming changes from a plugin.Defaults to 'debezium | debezium | String
| *slotRetryDelayMs* (postgres) | Time to wait between retry attempts when the connector fails to connect to a replication slot, given in milliseconds. Defaults to 10 seconds (10,000 ms). | 10s | long
| *slotStreamParams* (postgres) | Any optional parameters used by logical decoding plugin. Semi-colon separated. E.g. 'add-tables=public.table,public.table2;include-lsn=true' |  | String
| *snapshotCustomClass* (postgres) | When 'snapshot.mode' is set as custom, this setting must be set to specify a fully qualified class name to load (via the default class loader).This class must implement the 'Snapshotter' interface and is called on each app boot to determine whether to do a snapshot and how to build queries. |  | String
| *snapshotDelayMs* (postgres) | A delay period before a snapshot will begin, given in milliseconds. Defaults to 0 ms. | 0ms | long
| *snapshotFetchSize* (postgres) | The maximum number of records that should be loaded into memory while performing a snapshot |  | int
| *snapshotIncludeCollectionList* (postgres) | this setting must be set to specify a list of tables/collections whose snapshot must be taken on creating or restarting the connector. |  | String
| *snapshotLockTimeoutMs* (postgres) | The maximum number of millis to wait for table locks at the beginning of a snapshot. If locks cannot be acquired in this time frame, the snapshot will be aborted. Defaults to 10 seconds | 10s | long
| *snapshotMaxThreads* (postgres) | The maximum number of threads used to perform the snapshot. Defaults to 1. | 1 | int
| *snapshotMode* (postgres) | The criteria for running a snapshot upon startup of the connector. Options include: 'always' to specify that the connector run a snapshot each time it starts up; 'initial' (the default) to specify the connector can run a snapshot only when no offsets are available for the logical server name; 'initial_only' same as 'initial' except the connector should stop after completing the snapshot and before it would normally start emitting changes;'never' to specify the connector should never run a snapshot and that upon first startup the connector should read from the last position (LSN) recorded by the server; and'exported' deprecated, use 'initial' instead; 'custom' to specify a custom class with 'snapshot.custom_class' which will be loaded and used to determine the snapshot, see docs for more details. | initial | String
| *snapshotSelectStatement{zwsp}Overrides* (postgres) | This property contains a comma-separated list of fully-qualified tables (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on thespecific connectors. Select statements for the individual tables are specified in further configuration properties, one for each table, identified by the id 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', respectively. The value of those properties is the select statement to use when retrieving data from the specific table during snapshotting. A possible use case for large append-only tables is setting a specific point where to start (resume) snapshotting, in case a previous snapshotting was interrupted. |  | String
| *sourceStructVersion* (postgres) | A version of the format of the publicly visible source part in the message | v2 | String
| *statusUpdateIntervalMs* (postgres) | Frequency for sending replication connection status updates to the server, given in milliseconds. Defaults to 10 seconds (10,000 ms). | 10s | int
| *tableBlacklist* (postgres) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring (deprecated, use table.exclude.list instead) |  | String
| *tableExcludeList* (postgres) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring |  | String
| *tableIgnoreBuiltin* (postgres) | Flag specifying whether built-in tables should be ignored. | true | boolean
| *tableIncludeList* (postgres) | The tables for which changes are to be captured |  | String
| *tableWhitelist* (postgres) | The tables for which changes are to be captured (deprecated, use table.include.list instead) |  | String
| *timePrecisionMode* (postgres) | Time, date, and timestamps can be represented with different kinds of precisions, including:'adaptive' (the default) bases the precision of time, date, and timestamp values on the database column's precision; 'adaptive_time_microseconds' like 'adaptive' mode, but TIME fields always use microseconds precision;'connect' always represents time, date, and timestamp values using Kafka Connect's built-in representations for Time, Date, and Timestamp, which uses millisecond precision regardless of the database columns' precision . | adaptive | String
| *toastedValuePlaceholder* (postgres) | Specify the constant that will be provided by Debezium to indicate that the original value is a toasted value not provided by the database. If starts with 'hex:' prefix it is expected that the rest of the string repesents hexadecimally encoded octets. | __debezium_unavailable_value | String
| *tombstonesOnDelete* (postgres) | Whether delete operations should be represented by a delete event and a subsquenttombstone event (true) or only by a delete event (false). Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted. | false | boolean
| *xminFetchIntervalMs* (postgres) | Specify how often (in ms) the xmin will be fetched from the replication slot. This xmin value is exposed by the slot which gives a lower bound of where a new replication slot could start from. The lower the value, the more likely this value is to be the current 'true' value, but the bigger the performance cost. The bigger the value, the less likely this value is to be the current 'true' value, but the lower the performance penalty. The default is set to 0 ms, which disables tracking xmin. | 0ms | long
|===
// component options: END

// endpoint options: START
== Endpoint Options

The Debezium PostgresSQL Connector endpoint is configured using URI syntax:

----
debezium-postgres:name
----

with the following path and query parameters:

=== Path Parameters (1 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *name* | *Required* Unique name for the connector. Attempting to register again with the same name will fail. |  | String
|===


=== Query Parameters (89 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *additionalProperties* (common) | Additional properties for debezium components in case they can't be set directly on the camel configurations (e.g: setting Kafka Connect properties needed by Debezium engine, for example setting KafkaOffsetBackingStore), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro |  | Map
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *internalKeyConverter* (consumer) | The Converter class that should be used to serialize and deserialize key data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *internalValueConverter* (consumer) | The Converter class that should be used to serialize and deserialize value data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *offsetCommitPolicy* (consumer) | The name of the Java class of the commit policy. It defines when offsets commit has to be triggered based on the number of events processed and the time elapsed since the last commit. This class must implement the interface 'OffsetCommitPolicy'. The default is a periodic commit policy based upon time intervals. | io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy | String
| *offsetCommitTimeoutMs* (consumer) | Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt. The default is 5 seconds. | 5s | long
| *offsetFlushIntervalMs* (consumer) | Interval at which to try committing offsets. The default is 1 minute. | 60s | long
| *offsetStorage* (consumer) | The name of the Java class that is responsible for persistence of connector offsets. | org.apache.kafka.connect.storage.FileOffsetBackingStore | String
| *offsetStorageFileName* (consumer) | Path to file where offsets are to be stored. Required when offset.storage is set to the FileOffsetBackingStore. |  | String
| *offsetStoragePartitions* (consumer) | The number of partitions used when creating the offset storage topic. Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |  | int
| *offsetStorageReplicationFactor* (consumer) | Replication factor used when creating the offset storage topic. Required when offset.storage is set to the KafkaOffsetBackingStore |  | int
| *offsetStorageTopic* (consumer) | The name of the Kafka topic where offsets are to be stored. Required when offset.storage is set to the KafkaOffsetBackingStore. |  | String
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *binaryHandlingMode* (postgres) | Specify how binary (blob, binary, etc.) columns should be represented in change events, including:'bytes' represents binary data as byte array (default)'base64' represents binary data as base64-encoded string'hex' represents binary data as hex-encoded (base16) string | bytes | String
| *columnBlacklist* (postgres) | Regular expressions matching columns to exclude from change events (deprecated, use column.exclude.list instead) |  | String
| *columnExcludeList* (postgres) | Regular expressions matching columns to exclude from change events |  | String
| *columnIncludeList* (postgres) | Regular expressions matching columns to include in change events |  | String
| *columnPropagateSourceType* (postgres) | A comma-separated list of regular expressions matching fully-qualified names of columns that adds the columns original type and original length as parameters to the corresponding field schemas in the emitted change records. |  | String
| *columnWhitelist* (postgres) | Regular expressions matching columns to include in change events (deprecated, use column.include.list instead) |  | String
| *converters* (postgres) | Optional list of custom converters that would be used instead of default ones. The converters are defined using '.type' config option and configured using options '.' |  | String
| *databaseDbname* (postgres) | The name of the database the connector should be monitoring |  | String
| *databaseHistoryFileFilename* (postgres) | The path to the file that will be used to record the database history |  | String
| *databaseHostname* (postgres) | Resolvable hostname or IP address of the database server. |  | String
| *databaseInitialStatements* (postgres) | A semicolon separated list of SQL statements to be executed when a JDBC connection to the database is established. Note that the connector may establish JDBC connections at its own discretion, so this should typically be used for configurationof session parameters only, but not for executing DML statements. Use doubled semicolon (';;') to use a semicolon as a character and not as a delimiter. |  | String
| *databasePassword* (postgres) | *Required* Password of the database user to be used when connecting to the database. |  | String
| *databasePort* (postgres) | Port of the database server. | 5432 | int
| *databaseServerName* (postgres) | *Required* Unique name that identifies the database server and all recorded offsets, and that is used as a prefix for all schemas and topics. Each distinct installation should have a separate namespace and be monitored by at most one Debezium connector. |  | String
| *databaseSslcert* (postgres) | File containing the SSL Certificate for the client. See the Postgres SSL docs for further information |  | String
| *databaseSslfactory* (postgres) | A name of class to that creates SSL Sockets. Use org.postgresql.ssl.NonValidatingFactory to disable SSL validation in development environments |  | String
| *databaseSslkey* (postgres) | File containing the SSL private key for the client. See the Postgres SSL docs for further information |  | String
| *databaseSslmode* (postgres) | Whether to use an encrypted connection to Postgres. Options include'disable' (the default) to use an unencrypted connection; 'require' to use a secure (encrypted) connection, and fail if one cannot be established; 'verify-ca' like 'required' but additionally verify the server TLS certificate against the configured Certificate Authority (CA) certificates, or fail if no valid matching CA certificates are found; or'verify-full' like 'verify-ca' but additionally verify that the server certificate matches the host to which the connection is attempted. | disable | String
| *databaseSslpassword* (postgres) | Password to access the client private key from the file specified by 'database.sslkey'. See the Postgres SSL docs for further information |  | String
| *databaseSslrootcert* (postgres) | File containing the root certificate(s) against which the server is validated. See the Postgres JDBC SSL docs for further information |  | String
| *databaseTcpkeepalive* (postgres) | Enable or disable TCP keep-alive probe to avoid dropping TCP connection | true | boolean
| *databaseUser* (postgres) | Name of the database user to be used when connecting to the database. |  | String
| *datatypePropagateSourceType* (postgres) | A comma-separated list of regular expressions matching the database-specific data type names that adds the data type's original type and original length as parameters to the corresponding field schemas in the emitted change records. |  | String
| *decimalHandlingMode* (postgres) | Specify how DECIMAL and NUMERIC columns should be represented in change events, including:'precise' (the default) uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to represent values; 'double' represents values using Java's 'double', which may not offer the precision but will be far easier to use in consumers. | precise | String
| *eventProcessingFailureHandling{zwsp}Mode* (postgres) | Specify how failures during processing of events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its position is raised, causing the connector to be stopped; 'warn' the problematic event and its position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *heartbeatActionQuery* (postgres) | The query executed with every heartbeat. |  | String
| *heartbeatIntervalMs* (postgres) | Length of an interval in milli-seconds in in which the connector periodically sends heartbeat messages to a heartbeat topic. Use 0 to disable heartbeat messages. Disabled by default. | 0ms | int
| *heartbeatTopicsPrefix* (postgres) | The prefix that is used to name heartbeat topics.Defaults to __debezium-heartbeat. | __debezium-heartbeat | String
| *hstoreHandlingMode* (postgres) | Specify how HSTORE columns should be represented in change events, including:'json' represents values as string-ified JSON (default)'map' represents values as a key/value map | json | String
| *includeUnknownDatatypes* (postgres) | Specify whether the fields of data type not supported by Debezium should be processed:'false' (the default) omits the fields; 'true' converts the field into an implementation dependent binary representation. | false | boolean
| *incrementalSnapshotChunkSize* (postgres) | The maximum size of chunk for incremental snapshotting | 1024 | int
| *intervalHandlingMode* (postgres) | Specify how INTERVAL columns should be represented in change events, including:'string' represents values as an exact ISO formatted string'numeric' (default) represents values using the inexact conversion into microseconds | numeric | String
| *maxBatchSize* (postgres) | Maximum size of each batch of source records. Defaults to 2048. | 2048 | int
| *maxQueueSize* (postgres) | Maximum size of the queue for change events read from the database log but not yet recorded or forwarded. Defaults to 8192, and should always be larger than the maximum batch size. | 8192 | int
| *maxQueueSizeInBytes* (postgres) | Maximum size of the queue in bytes for change events read from the database log but not yet recorded or forwarded. Defaults to 0. Mean the feature is not enabled | 0 | long
| *messageKeyColumns* (postgres) | A semicolon-separated list of expressions that match fully-qualified tables and column(s) to be used as message key. Each expression must match the pattern ':',where the table names could be defined as (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the specific connector,and the key columns are a comma-separated list of columns representing the custom key. For any table without an explicit key configuration the table's primary key column(s) will be used as message key.Example: dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |  | String
| *pluginName* (postgres) | The name of the Postgres logical decoding plugin installed on the server. Supported values are 'decoderbufs', 'wal2json', 'pgoutput', 'wal2json_streaming', 'wal2json_rds' and 'wal2json_rds_streaming'. Defaults to 'decoderbufs'. | decoderbufs | String
| *pollIntervalMs* (postgres) | Time to wait for new change events to appear after receiving no events, given in milliseconds. Defaults to 500 ms. | 500ms | long
| *provideTransactionMetadata* (postgres) | Enables transaction metadata extraction together with event counting | false | boolean
| *publicationAutocreateMode* (postgres) | Applies only when streaming changes using pgoutput.Determine how creation of a publication should work, the default is all_tables.DISABLED - The connector will not attempt to create a publication at all. The expectation is that the user has created the publication up-front. If the publication isn't found to exist upon startup, the connector will throw an exception and stop.ALL_TABLES - If no publication exists, the connector will create a new publication for all tables. Note this requires that the configured user has access. If the publication already exists, it will be used. i.e CREATE PUBLICATION FOR ALL TABLES;FILTERED - If no publication exists, the connector will create a new publication for all those tables matchingthe current filter configuration (see table/database include/exclude list properties). If the publication already exists, it will be used. i.e CREATE PUBLICATION FOR TABLE | all_tables | String
| *publicationName* (postgres) | The name of the Postgres 10 publication used for streaming changes from a plugin.Defaults to 'dbz_publication' | dbz_publication | String
| *queryFetchSize* (postgres) | The maximum number of records that should be loaded into memory while streaming. A value of 0 uses the default JDBC fetch size. | 0 | int
| *retriableRestartConnectorWait{zwsp}Ms* (postgres) | Time to wait before restarting connector after retriable exception occurs. Defaults to 10000ms. | 10s | long
| *sanitizeFieldNames* (postgres) | Whether field names will be sanitized to Avro naming conventions | false | boolean
| *schemaBlacklist* (postgres) | The schemas for which events must not be captured (deprecated, use schema.exclude.list instead) |  | String
| *schemaExcludeList* (postgres) | The schemas for which events must not be captured |  | String
| *schemaIncludeList* (postgres) | The schemas for which events should be captured |  | String
| *schemaRefreshMode* (postgres) | Specify the conditions that trigger a refresh of the in-memory schema for a table. 'columns_diff' (the default) is the safest mode, ensuring the in-memory schema stays in-sync with the database table's schema at all times. 'columns_diff_exclude_unchanged_toast' instructs the connector to refresh the in-memory schema cache if there is a discrepancy between it and the schema derived from the incoming message, unless unchanged TOASTable data fully accounts for the discrepancy. This setting can improve connector performance significantly if there are frequently-updated tables that have TOASTed data that are rarely part of these updates. However, it is possible for the in-memory schema to become outdated if TOASTable columns are dropped from the table. | columns_diff | String
| *schemaWhitelist* (postgres) | The schemas for which events should be captured (deprecated, use schema.include.list instead) |  | String
| *signalDataCollection* (postgres) | The name of the data collection that is used to send signals/commands to Debezium. Signaling is disabled when not set. |  | String
| *skippedOperations* (postgres) | The comma-separated list of operations to skip during streaming, defined as: 'c' for inserts/create; 'u' for updates; 'd' for deletes. By default, no operations will be skipped. |  | String
| *slotDropOnStop* (postgres) | Whether or not to drop the logical replication slot when the connector finishes orderlyBy default the replication is kept so that on restart progress can resume from the last recorded location | false | boolean
| *slotMaxRetries* (postgres) | How many times to retry connecting to a replication slot when an attempt fails. | 6 | int
| *slotName* (postgres) | The name of the Postgres logical decoding slot created for streaming changes from a plugin.Defaults to 'debezium | debezium | String
| *slotRetryDelayMs* (postgres) | Time to wait between retry attempts when the connector fails to connect to a replication slot, given in milliseconds. Defaults to 10 seconds (10,000 ms). | 10s | long
| *slotStreamParams* (postgres) | Any optional parameters used by logical decoding plugin. Semi-colon separated. E.g. 'add-tables=public.table,public.table2;include-lsn=true' |  | String
| *snapshotCustomClass* (postgres) | When 'snapshot.mode' is set as custom, this setting must be set to specify a fully qualified class name to load (via the default class loader).This class must implement the 'Snapshotter' interface and is called on each app boot to determine whether to do a snapshot and how to build queries. |  | String
| *snapshotDelayMs* (postgres) | A delay period before a snapshot will begin, given in milliseconds. Defaults to 0 ms. | 0ms | long
| *snapshotFetchSize* (postgres) | The maximum number of records that should be loaded into memory while performing a snapshot |  | int
| *snapshotIncludeCollectionList* (postgres) | this setting must be set to specify a list of tables/collections whose snapshot must be taken on creating or restarting the connector. |  | String
| *snapshotLockTimeoutMs* (postgres) | The maximum number of millis to wait for table locks at the beginning of a snapshot. If locks cannot be acquired in this time frame, the snapshot will be aborted. Defaults to 10 seconds | 10s | long
| *snapshotMaxThreads* (postgres) | The maximum number of threads used to perform the snapshot. Defaults to 1. | 1 | int
| *snapshotMode* (postgres) | The criteria for running a snapshot upon startup of the connector. Options include: 'always' to specify that the connector run a snapshot each time it starts up; 'initial' (the default) to specify the connector can run a snapshot only when no offsets are available for the logical server name; 'initial_only' same as 'initial' except the connector should stop after completing the snapshot and before it would normally start emitting changes;'never' to specify the connector should never run a snapshot and that upon first startup the connector should read from the last position (LSN) recorded by the server; and'exported' deprecated, use 'initial' instead; 'custom' to specify a custom class with 'snapshot.custom_class' which will be loaded and used to determine the snapshot, see docs for more details. | initial | String
| *snapshotSelectStatement{zwsp}Overrides* (postgres) | This property contains a comma-separated list of fully-qualified tables (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on thespecific connectors. Select statements for the individual tables are specified in further configuration properties, one for each table, identified by the id 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', respectively. The value of those properties is the select statement to use when retrieving data from the specific table during snapshotting. A possible use case for large append-only tables is setting a specific point where to start (resume) snapshotting, in case a previous snapshotting was interrupted. |  | String
| *sourceStructVersion* (postgres) | A version of the format of the publicly visible source part in the message | v2 | String
| *statusUpdateIntervalMs* (postgres) | Frequency for sending replication connection status updates to the server, given in milliseconds. Defaults to 10 seconds (10,000 ms). | 10s | int
| *tableBlacklist* (postgres) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring (deprecated, use table.exclude.list instead) |  | String
| *tableExcludeList* (postgres) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring |  | String
| *tableIgnoreBuiltin* (postgres) | Flag specifying whether built-in tables should be ignored. | true | boolean
| *tableIncludeList* (postgres) | The tables for which changes are to be captured |  | String
| *tableWhitelist* (postgres) | The tables for which changes are to be captured (deprecated, use table.include.list instead) |  | String
| *timePrecisionMode* (postgres) | Time, date, and timestamps can be represented with different kinds of precisions, including:'adaptive' (the default) bases the precision of time, date, and timestamp values on the database column's precision; 'adaptive_time_microseconds' like 'adaptive' mode, but TIME fields always use microseconds precision;'connect' always represents time, date, and timestamp values using Kafka Connect's built-in representations for Time, Date, and Timestamp, which uses millisecond precision regardless of the database columns' precision . | adaptive | String
| *toastedValuePlaceholder* (postgres) | Specify the constant that will be provided by Debezium to indicate that the original value is a toasted value not provided by the database. If starts with 'hex:' prefix it is expected that the rest of the string repesents hexadecimally encoded octets. | __debezium_unavailable_value | String
| *tombstonesOnDelete* (postgres) | Whether delete operations should be represented by a delete event and a subsquenttombstone event (true) or only by a delete event (false). Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted. | false | boolean
| *xminFetchIntervalMs* (postgres) | Specify how often (in ms) the xmin will be fetched from the replication slot. This xmin value is exposed by the slot which gives a lower bound of where a new replication slot could start from. The lower the value, the more likely this value is to be the current 'true' value, but the bigger the performance cost. The bigger the value, the less likely this value is to be the current 'true' value, but the lower the performance penalty. The default is set to 0 ms, which disables tracking xmin. | 0ms | long
|===
// endpoint options: END

For more information about configuration:
https://debezium.io/documentation/reference/0.10/operations/embedded.html#engine-properties[https://debezium.io/documentation/reference/0.10/operations/embedded.html#engine-properties]
https://debezium.io/documentation/reference/0.10/connectors/postgresql.html#connector-properties[https://debezium.io/documentation/reference/0.10/connectors/postgresql.html#connector-properties]

== Message headers

=== Consumer headers

The following headers are available when consuming change events from Debezium.
[width=""100%"",cols=""2m,2m,1m,5"",options=""header""]
|===
| Header constant                           | Header value                                   | Type        | Description
| DebeziumConstants.HEADER_IDENTIFIER       | ""CamelDebeziumIdentifier""                      | String      | The identifier of the connector, normally is this format ""+++{server-name}.{database-name}.{table-name}+++"".
| DebeziumConstants.HEADER_KEY              | ""CamelDebeziumKey""                             | Struct      | The key of the event, normally is the table Primary Key.
| DebeziumConstants.HEADER_SOURCE_METADATA  | ""CamelDebeziumSourceMetadata""                  | Map         | The metadata about the source event, for example `table` name, database `name`, log position, etc, please refer to the Debezium documentation for more info.
| DebeziumConstants.HEADER_OPERATION        | ""CamelDebeziumOperation""                       | String      | If presents, the type of event operation. Values for the connector are `c` for create (or insert), `u` for update, `d` for delete or `r` in case of a snapshot event.
| DebeziumConstants.HEADER_TIMESTAMP        | ""CamelDebeziumTimestamp""                       | Long        | If presents, the time (using the system clock in the JVM) at which the connector processed the event.
| DebeziumConstants.HEADER_BEFORE           | ""CamelDebeziumBefore""                          | Struct     | If presents, contains the state of the row before the event occurred.
|===

== Message body
The message body if is not `null` (in case of tombstones), it contains the state of the row after the event occurred as `Struct` format or `Map` format if you use the included Type Converter from `Struct` to `Map` (please look below for more explanation).

== Samples

=== Consuming events

Here is a very simple route that you can use in order to listen to Debezium events from PostgresSQL connector.

[source,java]
----
from(""debezium-postgres:dbz-test-1?offsetStorageFileName=/usr/offset-file-1.dat&databaseHostName=localhost&databaseUser=debezium&databasePassword=dbz&databaseServerName=my-app-connector&databaseHistoryFileName=/usr/history-file-1.dat"")
    .log(""Event received from Debezium : ${body}"")
    .log(""    with this identifier ${headers.CamelDebeziumIdentifier}"")
    .log(""    with these source metadata ${headers.CamelDebeziumSourceMetadata}"")
    .log(""    the event occured upon this operation '${headers.CamelDebeziumSourceOperation}'"")
    .log(""    on this database '${headers.CamelDebeziumSourceMetadata[db]}' and this table '${headers.CamelDebeziumSourceMetadata[table]}'"")
    .log(""    with the key ${headers.CamelDebeziumKey}"")
    .log(""    the previous value is ${headers.CamelDebeziumBefore}"")
----

By default, the component will emit the events in the body and `CamelDebeziumBefore` header as https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Struct.html[`Struct`] data type, the reasoning behind this, is to perceive the schema information in case is needed.
However, the component as well contains a xref:manual::type-converter.adoc[Type Converter] that converts
from default output type of https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Struct.html[`Struct`] to `Map` in order to leverage Camel's rich xref:manual::data-format.adoc[Data Format] types which many of them work out of box with `Map` data type.
To use it, you can either add `Map.class` type when you access the message e.g: `exchange.getIn().getBody(Map.class)`, or you can convert the body always to `Map` from the route builder by adding `.convertBodyTo(Map.class)` to your Camel Route DSL after `from` statement.

We mentioned above about the schema, which can be used in case you need to perform advance data transformation and the schema is needed for that. If you choose not to convert your body to `Map`,
you can obtain the schema information as https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Schema.html[`Schema`] type from `Struct` like this:

[source,java]
----
from(""debezium-postgres:[name]?[options]])
    .process(exchange -> {
        final Struct bodyValue = exchange.getIn().getBody(Struct.class);
        final Schema schemaValue = bodyValue.schema();

        log.info(""Body value is :"" + bodyValue);
        log.info(""With Schema : "" + schemaValue);
        log.info(""And fields of :"" + schemaValue.fields());
        log.info(""Field name has `"" + schemaValue.field(""name"").schema() + ""` type"");
    });
----

*Important Note:* This component is a thin wrapper around Debezium Engine as mentioned, therefore before using this component in production, you need to understand how Debezium works and how configurations can reflect the expected behavior, especially in regards to https://debezium.io/documentation/reference/0.9/operations/embedded.html#_handling_failures[handling failures].

include::{page-component-version}@camel-spring-boot::page$debezium-postgres-starter.adoc[]
",12200,True,2975.249899792454,median
"/**
 * Tencent is pleased to support the open source community by making Tars available.
 *
 * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the ""License""); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * 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 ""util/tc_epoll_server.h""
#include ""util/tc_port.h""
#include ""util/tc_common.h""
#include ""util/tc_network_buffer.h""
#include ""util/tc_timeprovider.h""
#include <cassert>
#include <iostream>


//#define FILE_FUNC_LINE          ""["" << __FILE__ << ""::"" << __FUNCTION__ << ""::"" << __LINE__ << ""]"" 
//#define LOG_CONSOLE cout << this_thread::get_id() <<""|""<< TC_Common::now2str()<< FILE_FUNC_LINE << ""|""

#if TARGET_PLATFORM_WINDOWS
#include <WS2tcpip.h>
#else
#include <arpa/inet.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>

#endif

#if TARS_SSL
#include ""util/tc_openssl.h""
#endif


namespace tars
{

static const int BUFFER_SIZE = 8 * 1024;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// handle的实现
TC_EpollServer::Handle::Handle() 
: _pEpollServer(NULL)
, _iWaitTime(100)
{
}

TC_EpollServer::Handle::~Handle()
{
}

void TC_EpollServer::Handle::handleClose(const shared_ptr<TC_EpollServer::RecvContext> &data)
{
}

void TC_EpollServer::Handle::sendResponse(const shared_ptr<TC_EpollServer::SendContext> &data)//uint32_t uid, const vector<char> &sSendBuffer, const string &ip, int port, int fd)
{
    _pEpollServer->send(data);
}

void TC_EpollServer::Handle::close(const shared_ptr<TC_EpollServer::RecvContext> &data)
{
    _pEpollServer->close(data);
}

void TC_EpollServer::Handle::handleTimeout(const shared_ptr<TC_EpollServer::RecvContext> &data)
{
    _pEpollServer->error(""[Handle::handleTimeout] queue timeout, close ["" + data->ip() + "":"" + TC_Common::tostr(data->port()) + ""]."");

    close(data);
}

void TC_EpollServer::Handle::handleOverload(const shared_ptr<TC_EpollServer::RecvContext> &data)
{
    _pEpollServer->error(""[Handle::handleOverload] adapter '"" + data->adapter()->getName() + ""',over load:"" + TC_Common::tostr(data->adapter()->getRecvBufferSize()) + "">"" + TC_Common::tostr(data->adapter()->getQueueCapacity()) + ""."");

    close(data);
}

void TC_EpollServer::Handle::run()
{
    initialize();

    handleImp();
}

bool TC_EpollServer::Handle::allAdapterIsEmpty()
{
    if (_bindAdapter->getRecvBufferSize() > 0)
    {
        return false;
    }

    return true;
}

bool TC_EpollServer::Handle::allFilterIsEmpty()
{
    return true;
}

void TC_EpollServer::Handle::setEpollServer(TC_EpollServer *pEpollServer)
{
    _pEpollServer = pEpollServer;
}

void TC_EpollServer::Handle::setBindAdapter(BindAdapter*  bindAdapter)
{
    _bindAdapter = bindAdapter;
}

void TC_EpollServer::Handle::setHandleIndex(uint32_t index)
{
    _handleIndex = index;
}

void TC_EpollServer::Handle::setNetThread(NetThread *netThread)
{
    _netThread = netThread;
}

void TC_EpollServer::Handle::notifyFilter()
{
    _bindAdapter->notifyHandle(_handleIndex);
}

void TC_EpollServer::Handle::setWaitTime(uint32_t iWaitTime)
{
    _iWaitTime = iWaitTime;
}

void TC_EpollServer::Handle::process(shared_ptr<RecvContext> data)
{
    try
    {
        //上报心跳
        heartbeat();

        //为了实现所有主逻辑的单线程化,在每次循环中给业务处理自有消息的机会
        handleAsyncResponse();

        //数据已超载 overload
        if (data->isOverload())
        {
            handleOverload(data);
        }
            //关闭连接的通知消息
        else if (data->isClosed())
        {
            handleClose(data);
        }
            //数据在队列中已经超时了
        else if ((TNOWMS - data->recvTimeStamp()) > (int64_t)_bindAdapter->getQueueTimeout())
        {
            handleTimeout(data);
        }
        else
        {
            handle(data);
        }
        handleCustomMessage(false);
    }
    catch (exception &ex)
    {
        if (data)
        {
            close(data);
        }

        getEpollServer()->error(""[Handle::handleImp] error:"" + string(ex.what()));
    }
    catch (...)
    {
        if (data)
        {
            close(data);
        }

        getEpollServer()->error(""[Handle::handleImp] unknown error"");
    }
}

void TC_EpollServer::Handle::wait()
{
    if (allAdapterIsEmpty() && allFilterIsEmpty())
    {
        _bindAdapter->waitAtQueue(_handleIndex, _iWaitTime);
    }
}

bool TC_EpollServer::Handle::popRecvQueue(shared_ptr<RecvContext> &recv)
{
    return _bindAdapter->waitForRecvQueue(_handleIndex, recv);
}

void TC_EpollServer::Handle::handleImp()
{
    //by goodenpei, 判断是否启用顺序模式
    _bindAdapter->initThreadRecvQueue(getHandleIndex());

    startHandle();

    while (!getEpollServer()->isTerminate())
    {
        //等待
        wait();

        //上报心跳
        heartbeat();

        //为了实现所有主逻辑的单线程化,在每次循环中给业务处理自有消息的机会
        handleAsyncResponse();
        handleCustomMessage(true);

        shared_ptr<RecvContext> data;

        try
        {
            while (popRecvQueue(data))//_bindAdapter->waitForRecvQueue(_handleIndex, data))
            {
                //上报心跳
                heartbeat();

                //为了实现所有主逻辑的单线程化,在每次循环中给业务处理自有消息的机会
                handleAsyncResponse();

                //数据已超载 overload
                if (data->isOverload())
                {
                    handleOverload(data);
                }
                //关闭连接的通知消息
                else if (data->isClosed())
                {
                    handleClose(data);
                }
                //数据在队列中已经超时了
                else if ((TNOWMS - data->recvTimeStamp()) > (int64_t)_bindAdapter->getQueueTimeout())
                {
                    handleTimeout(data);
                }
                else
                {
                    handle(data);
                }
                handleCustomMessage(false);
            }
        }
        catch (exception &ex)
        {
            if (data)
            {
                close(data);
            }

            getEpollServer()->error(""[Handle::handleImp] error:"" + string(ex.what()));
        }
        catch (...)
        {
            if (data)
            {
                close(data);
            }

            getEpollServer()->error(""[Handle::handleImp] unknown error"");
        }
    }

    stopHandle();
}

////////////////////////////BindAdapter///////////////////////////////////
TC_EpollServer::BindAdapter::BindAdapter(TC_EpollServer *pEpollServer)
    : _pReportQueue(NULL)
    , _pReportConRate(NULL)
    , _pReportTimeoutNum(NULL)
    , _pEpollServer(pEpollServer)
    ,  _pf(echo_protocol)
    , _hf(echo_header_filter)
    , _name("""")
    , _iMaxConns(DEFAULT_MAX_CONN)
    , _iCurConns(0)
    , _iHandleNum(0)
    , _eOrder(ALLOW_DENY)
    , _iQueueCapacity(DEFAULT_QUEUE_CAP)
    , _iQueueTimeout(DEFAULT_QUEUE_TIMEOUT)
    , _iHeaderLen(0)
    , _iHeartBeatTime(0)
    , _protocolName(""tars"")
{
}

TC_EpollServer::BindAdapter::~BindAdapter()
{
}

void TC_EpollServer::BindAdapter::setProtocolName(const string &name)
{
    std::lock_guard<std::mutex> lock (_mutex);

    _protocolName = name;
}

const string &TC_EpollServer::BindAdapter::getProtocolName()
{
    std::lock_guard<std::mutex> lock (_mutex);

    return _protocolName;
}

bool TC_EpollServer::BindAdapter::isTarsProtocol()
{
    return (_protocolName == ""tars"");
}

bool TC_EpollServer::BindAdapter::isIpAllow(const string &ip) const
{
    std::lock_guard<std::mutex> lock (_mutex);

    if (_eOrder == ALLOW_DENY)
    {
        if (TC_Common::matchPeriod(ip, _vtAllow))
        {
            return true;
        }
        if (TC_Common::matchPeriod(ip, _vtDeny))
        {
            return false;
        }
    }
    else
    {
        if (TC_Common::matchPeriod(ip, _vtDeny))
        {
            return false;
        }
        if (TC_Common::matchPeriod(ip, _vtAllow))
        {
            return true;
        }
    }
    return _vtAllow.size() == 0;
}

void TC_EpollServer::BindAdapter::manualListen()
{
    this->getEpollServer()->_epoller.mod(getSocket().getfd(), getSocket().getfd(), EPOLLIN|EPOLLOUT);
}

void TC_EpollServer::BindAdapter::initThreadRecvQueue(uint32_t handeIndex)
{
    if(isQueueMode()) {
        _threadDataQueue[handeIndex + 1] = std::make_shared<BindAdapter::DataQueue>();
    }
}

TC_EpollServer::recv_queue &TC_EpollServer::BindAdapter::getRecvQueue(uint32_t handleIndex)
{
    if(isQueueMode())
    {
        return _threadDataQueue[handleIndex+1]->_rbuffer;
    }

    return _threadDataQueue[0]->_rbuffer;
}

TC_ThreadLock &TC_EpollServer::BindAdapter::getLock(uint32_t handleIndex)
{
    if(isQueueMode())
    {
        return _threadDataQueue[handleIndex+1]->_monitor;
    }

    return _threadDataQueue[0]->_monitor;
}

void TC_EpollServer::BindAdapter::waitAtQueue(uint32_t handleIndex, uint32_t waitTime)
{
    TC_ThreadLock &l = getLock(handleIndex);

    TC_ThreadLock::Lock lock(l);

    l.timedWait(waitTime);
}

void TC_EpollServer::BindAdapter::notifyHandle(uint32_t handleIndex)
{
    if(this->getEpollServer()->isMergeHandleNetThread())
    {
        //业务线程和网络线程合并了, 直接通知网络线程醒过来即可
        NetThread *netThread = getHandle(handleIndex)->getNetThread();

        assert(netThread != NULL);

        netThread->notify();
    }
    else {
        //通知对应的Handle线程队列醒过来
        if (isQueueMode()) {
            handleIndex = handleIndex + 1;
            //相同连接过来的进入同一个buffer, 被Handle的同一个线程处理
            TC_ThreadLock::Lock lock(_threadDataQueue[handleIndex]->_monitor);
            _threadDataQueue[handleIndex]->_monitor.notify();
        }
        else {
            TC_ThreadLock::Lock lock(_threadDataQueue[0]->_monitor);
            _threadDataQueue[0]->_monitor.notifyAll();
        }
    }
}

void TC_EpollServer::BindAdapter::insertRecvQueue(const shared_ptr<RecvContext> &recv)
{
    _iRecvBufferSize++;

    size_t idx = 0;

    if(isQueueMode()) {
        //相同连接过来的进入同一个buffer, 被Handle的同一个线程处理
        idx = recv->fd() % _iHandleNum + 1;
    }
    _threadDataQueue[idx]->_rbuffer.push_back(recv);

    //通知对应的线程队列醒过来
    TC_ThreadLock::Lock lock(_threadDataQueue[idx]->_monitor);
    _threadDataQueue[idx]->_monitor.notify();

}

bool TC_EpollServer::BindAdapter::waitForRecvQueue(uint32_t handleIndex, shared_ptr<RecvContext> &data)
{
    bool bRet = getRecvQueue(handleIndex).pop_front(data);

    if (!bRet)
    {
        return bRet;
    }

    --_iRecvBufferSize;

    return bRet;
}

size_t TC_EpollServer::BindAdapter::getRecvBufferSize() const
{
    return _iRecvBufferSize;
}

size_t TC_EpollServer::BindAdapter::getSendBufferSize() const
{
    return _iSendBufferSize;
}

TC_NetWorkBuffer::PACKET_TYPE TC_EpollServer::BindAdapter::echo_protocol(TC_NetWorkBuffer &r, vector<char> &o)
{
    o = r.getBuffers();

    r.clearBuffers();

    return TC_NetWorkBuffer::PACKET_FULL;
}

TC_NetWorkBuffer::PACKET_TYPE TC_EpollServer::BindAdapter::echo_header_filter(TC_NetWorkBuffer::PACKET_TYPE i, vector<char> &o)
{
    return TC_NetWorkBuffer::PACKET_FULL;
}

void TC_EpollServer::BindAdapter::setName(const string &name)
{
    std::lock_guard<std::mutex> lock (_mutex);
    _name = name;
}

string TC_EpollServer::BindAdapter::getName() const
{
    std::lock_guard<std::mutex> lock (_mutex);
    return _name;
}

int TC_EpollServer::BindAdapter::getHandleNum()
{
    return _iHandleNum;
}

int TC_EpollServer::BindAdapter::getQueueCapacity() const
{
    return _iQueueCapacity;
}

void TC_EpollServer::BindAdapter::setQueueCapacity(int n)
{
    _iQueueCapacity = n;
}

int TC_EpollServer::BindAdapter::isOverloadorDiscard()
{
    int iRecvBufferSize = _iRecvBufferSize;

    if(iRecvBufferSize > (int)(_iQueueCapacity / 5.*4) && (iRecvBufferSize < _iQueueCapacity) && (_iQueueCapacity > 0)) //overload
    {
        //超过队列4/5开始认为过载
        return -1;
    }
    else if(iRecvBufferSize > (int)(_iQueueCapacity) &&  _iQueueCapacity > 0 ) //队列满需要丢弃接受的数据包
    {
        return -2;
    }
    return 0;
}

void TC_EpollServer::BindAdapter::setQueueTimeout(int t)
{
    if (t >= MIN_QUEUE_TIMEOUT)
    {
        _iQueueTimeout = t;
    }
    else
    {
        _iQueueTimeout = MIN_QUEUE_TIMEOUT;
    }
}

int TC_EpollServer::BindAdapter::getQueueTimeout() const
{
    return _iQueueTimeout;
}

void TC_EpollServer::BindAdapter::setEndpoint(const string &str)
{
    std::lock_guard<std::mutex> lock (_mutex);

    _ep.parse(str);
}

TC_Endpoint TC_EpollServer::BindAdapter::getEndpoint() const
{
    std::lock_guard<std::mutex> lock (_mutex);
    return _ep;
}

TC_Socket &TC_EpollServer::BindAdapter::getSocket()
{
    return _s;
}

void TC_EpollServer::BindAdapter::setMaxConns(int iMaxConns)
{
    _iMaxConns = iMaxConns;
}

size_t TC_EpollServer::BindAdapter::getMaxConns() const
{
    return _iMaxConns;
}

void TC_EpollServer::BindAdapter::setHeartBeatTime(time_t t)
{
    _iHeartBeatTime = t;
}

time_t TC_EpollServer::BindAdapter::getHeartBeatTime() const
{
    return _iHeartBeatTime;
}

void TC_EpollServer::BindAdapter::setOrder(EOrder eOrder)
{
    _eOrder = eOrder;
}

void TC_EpollServer::BindAdapter::setAllow(const vector<string> &vtAllow)
{
    std::lock_guard<std::mutex> lock (_mutex);

    _vtAllow = vtAllow;
}

void TC_EpollServer::BindAdapter::setDeny(const vector<string> &vtDeny)
{
    std::lock_guard<std::mutex> lock (_mutex);

    _vtDeny = vtDeny;
}

TC_EpollServer::BindAdapter::EOrder TC_EpollServer::BindAdapter::getOrder() const
{
    return _eOrder;
}

const vector<string> &TC_EpollServer::BindAdapter::getAllow() const
{
    return _vtAllow;
}

const vector<string> &TC_EpollServer::BindAdapter::getDeny() const
{
    return _vtDeny;
}

bool TC_EpollServer::BindAdapter::isLimitMaxConnection() const
{
    return (_iCurConns + 1 > _iMaxConns) || (_iCurConns + 1 > (int)((uint32_t)1 << 22) - 1);
}

void TC_EpollServer::BindAdapter::decreaseNowConnection()
{
    --_iCurConns;
}

void TC_EpollServer::BindAdapter::increaseNowConnection()
{
    ++_iCurConns;
}

int TC_EpollServer::BindAdapter::getNowConnection() const
{
    return _iCurConns;
}

vector<TC_EpollServer::ConnStatus> TC_EpollServer::BindAdapter::getConnStatus()
{
    return _pEpollServer->getConnStatus(_s.getfd());
}

void TC_EpollServer::BindAdapter::setProtocol(const TC_NetWorkBuffer::protocol_functor &pf, int iHeaderLen, const TC_EpollServer::header_filter_functor &hf)
{
    _pf = pf;

    _hf = hf;

    _iHeaderLen = iHeaderLen;
}

TC_NetWorkBuffer::protocol_functor &TC_EpollServer::BindAdapter::getProtocol()
{
    return _pf;
}

TC_EpollServer::header_filter_functor &TC_EpollServer::BindAdapter::getHeaderFilterFunctor()
{
    return _hf;
}

int TC_EpollServer::BindAdapter::getHeaderFilterLen()
{
    return _iHeaderLen;
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 服务连接
TC_EpollServer::Connection::Connection(TC_EpollServer::BindAdapter *pBindAdapter, int lfd, int timeout, int fd, const string& ip, uint16_t port)
: _pBindAdapter(pBindAdapter)
, _uid(0)
, _lfd(lfd)
, _timeout(timeout)
, _ip(ip)
, _port(port)
, _recvBuffer(this)
, _sendBuffer(this)
, _iHeaderLen(0)
, _bClose(false)
, _enType(EM_TCP)
, _bEmptyConn(true)
, _pRecvBuffer(NULL)
, _nRecvBufferSize(DEFAULT_RECV_BUFFERSIZE)
, _authInit(false)
{
    assert(fd != -1);

    _iLastRefreshTime = TNOW;

    _sock.init(fd, true, pBindAdapter->_ep.isIPv6() ? AF_INET6 : AF_INET);
}

TC_EpollServer::Connection::Connection(BindAdapter *pBindAdapter, int fd)
: _pBindAdapter(pBindAdapter)
, _uid(0)
, _lfd(-1)
, _timeout(2)
, _port(0)
, _recvBuffer(this)
, _sendBuffer(this)
, _iHeaderLen(0)
, _bClose(false)
, _enType(EM_UDP)
, _bEmptyConn(false) /*udp is always false*/
, _pRecvBuffer(NULL)
, _nRecvBufferSize(DEFAULT_RECV_BUFFERSIZE)

{
    _iLastRefreshTime = TNOW;

    _sock.init(fd, false, pBindAdapter->_ep.isIPv6() ? AF_INET6 : AF_INET);
}

TC_EpollServer::Connection::~Connection()
{
    if (_pRecvBuffer)
    {
        delete _pRecvBuffer;
        _pRecvBuffer = NULL;
    }

    if (isTcp())
    {
        assert(!_sock.isValid());
    }
}

void TC_EpollServer::Connection::tryInitAuthState(int initState)
{
    if (!_authInit)
    {
        _authState = initState;
        _authInit = true;
    }
}

void TC_EpollServer::Connection::close()
{
#if TARS_SSL
        if (_openssl)
        {
            _openssl->release();
            _openssl.reset();
        }
#endif

    if (isTcp() && _sock.isValid())
    {
        _pBindAdapter->decreaseSendBufferSize(_sendBuffer.size());

        _sock.close();
    }
}

void TC_EpollServer::Connection::insertRecvQueue(const shared_ptr<TC_EpollServer::RecvContext> &recv)
{
    if(_pBindAdapter->getEpollServer()->isMergeHandleNetThread())
    {
        int index = _pBindAdapter->getEpollServer()->getNetThreadOfFd(recv->fd())->getIndex();

        //直接在网络线程中调用handle的process
        _pBindAdapter->getHandle(index)->process(recv);
    }
    else
    {
        int iRet = _pBindAdapter->isOverloadorDiscard();

        if (iRet == 0) //未过载
        {
            _pBindAdapter->insertRecvQueue(recv);
        }
        else if (iRet == -1) //超过接受队列长度的一半，需要进行overload处理
        {
            recv->setOverload();

            _pBindAdapter->insertRecvQueue(recv);//, false);
        }
        else //接受队列满，需要丢弃
        {
            _pBindAdapter->getEpollServer()->error(""[Connection::insertRecvQueue] overload discard package"");
        }
    }
}

int TC_EpollServer::Connection::parseProtocol(TC_NetWorkBuffer &rbuf)
{
    try
    {
        while (!rbuf.empty())
        {
            //需要过滤首包包头
            if(_iHeaderLen > 0)
            {
                if(rbuf.getBufferLength() >= (unsigned)_iHeaderLen)
                {
                    vector<char> header;
                    rbuf.getHeader(_iHeaderLen, header);
                    _pBindAdapter->getHeaderFilterFunctor()(TC_NetWorkBuffer::PACKET_FULL, header);
                    rbuf.moveHeader(_iHeaderLen);
                    _iHeaderLen = 0;
                }
                else
                {
                    vector<char> header = rbuf.getBuffers();
                    _pBindAdapter->getHeaderFilterFunctor()(TC_NetWorkBuffer::PACKET_LESS, header);
                    _iHeaderLen -= (int)rbuf.getBufferLength();
                    rbuf.clearBuffers();
                    break;
                }
            }

            vector<char> ro;

            TC_NetWorkBuffer::PACKET_TYPE b = _pBindAdapter->getProtocol()(rbuf, ro);

            if(b == TC_NetWorkBuffer::PACKET_LESS)
            {
                break;
            }
            else if(b == TC_NetWorkBuffer::PACKET_FULL)
            {
                shared_ptr<RecvContext> recv = std::make_shared<RecvContext>(getId(), _ip, _port, getfd(), _pBindAdapter);

                recv->buffer().swap(ro);

                if (_pBindAdapter->getEndpoint().isTcp() && _pBindAdapter->_authWrapper && _pBindAdapter->_authWrapper(this, recv))
                    continue;

                //收到完整的包才算
                this->_bEmptyConn = false;

                //收到完整包
                insertRecvQueue(recv);
            }
            else
            {
                _pBindAdapter->getEpollServer()->error(""recv ["" + _ip + "":"" + TC_Common::tostr(_port) + ""], packet parse error."");
                return -1; //协议解析错误
            }
        }
    }
    catch(exception &ex)
    {
        _pBindAdapter->getEpollServer()->error(""recv protocol error:"" + string(ex.what()));
        return -1;
    }
    catch(...)
    {
        _pBindAdapter->getEpollServer()->error(""recv protocol error"");
        return -1;
    }

    return 0;
}

int TC_EpollServer::Connection::recvTcp()
{
    int recvCount = 0;

    TC_NetWorkBuffer *rbuf = &_recvBuffer;

    while (true)
    {
        char buffer[BUFFER_SIZE] = {0x00};

        int iBytesReceived = _sock.recv((void *)buffer, BUFFER_SIZE);

        if (iBytesReceived < 0)
        {
            if (TC_Socket::isPending())
            {
                //没有数据了
                break;
            }
            else
            {
                //客户端主动关闭
                _pBindAdapter->getEpollServer()->debug(""recv ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] close connection"");
                return -1;
            }
        }
        else if (iBytesReceived == 0)
        {
            //客户端主动关闭
            _pBindAdapter->getEpollServer()->debug(""recv ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] close connection"");
            return -1;
        }
        else
        {

#if TARS_SSL
		    if (_pBindAdapter->getEndpoint().isSSL())
		    {
			    int ret = _openssl->read(buffer, iBytesReceived, _sendBuffer);
			    if (ret != 0)
			    {
				    _pBindAdapter->getEpollServer()->error(""[SSL_read failed: "" + _openssl->getErrMsg());
				    return -1;
			    }
			    else
			    {
				    if (!_sendBuffer.empty())
				    {
					    sendBuffer();
				    }

				    rbuf = _openssl->recvBuffer();
			    }
		    }
		    else
		    {
			    rbuf->addBuffer(buffer, iBytesReceived);
		    }

#else
            rbuf->addBuffer(buffer, iBytesReceived);
#endif

            //字符串太长时, 强制解析协议
            if (rbuf->getBufferLength() > 8192) {
                parseProtocol(*rbuf);
            }

            //接收到数据不超过buffer,没有数据了(如果有数据,内核会再通知你)
            if ((size_t) iBytesReceived < BUFFER_SIZE) {
                break;
            }

            if(++recvCount > 100)
            {
                //太多数据要接收,避免网络线程饥饿
                _pBindAdapter->getNetThreadOfFd(_sock.getfd())->getEpoller()->mod(_sock.getfd(), getId(), EPOLLIN|EPOLLOUT);
                break;
            }
        }
    }

    return parseProtocol(*rbuf);
}

int TC_EpollServer::Connection::recvUdp()
{
    assert(_pRecvBuffer != NULL);

    int recvCount = 0;
    while (true)
    {
        int iBytesReceived = _sock.recvfrom((void *)_pRecvBuffer, _nRecvBufferSize, _ip, _port, 0);

        if (iBytesReceived < 0)
        {
            if (TC_Socket::isPending())//errno == EAGAIN)
            {
                //没有数据了
                break;
            }
            else
            {
                //客户端主动关闭
                _pBindAdapter->getEpollServer()->debug(""recv ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] close connection"");
                return -1;
            }
        }
        else if (iBytesReceived == 0)
        {
            //客户端主动关闭
            _pBindAdapter->getEpollServer()->debug(""recv ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] close connection"");
            return -1;
        }
        else
        {

            if (_pBindAdapter->isIpAllow(_ip) == true)
            {
                //保存接收到数据
                _recvBuffer.addBuffer(_pRecvBuffer, iBytesReceived);

                parseProtocol(_recvBuffer);
            }
            else
            {
                //udp ip无权限
                _pBindAdapter->getEpollServer()->debug( ""accept ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] ["" + TC_Common::tostr(_lfd) + ""] not allowed"");
            }
            _recvBuffer.clearBuffers();

            if(++recvCount > 100)
            {
                //太多数据要接收,避免网络线程饥饿
                _pBindAdapter->getNetThreadOfFd(_sock.getfd())->getEpoller()->mod(_sock.getfd(), getId(), EPOLLIN|EPOLLOUT);
                break;
            }
        }
    }

    return 0;
}

int TC_EpollServer::Connection::recv()
{
    return isTcp() ? recvTcp() : recvUdp();
}

int TC_EpollServer::Connection::sendBuffer()
{
    if(!isTcp())
    {
        return 0;
    }

	size_t nowSendBufferSize = 0;
	size_t nowLeftBufferSize = _sendBuffer.getBufferLength();

	while(!_sendBuffer.empty())
	{
		pair<const char*, size_t> data = _sendBuffer.getBufferPointer();

		int iBytesSent = _sock.send((const void *) data.first, data.second);
		// }
		// else
		// {
		// 	iBytesSent = _sock.sendto((const void *) data.first, data.second, _ip, _port, 0);
		// }

		if (iBytesSent < 0)
		{
			if (TC_Socket::isPending())
			{
#if TARGET_PLATFORM_WINDOWS
	            _pBindAdapter->getNetThreadOfFd(_sock.getfd())->getEpoller()->mod(_sock.getfd(), getId(), EPOLLIN|EPOLLOUT);
#endif
				break;
			}
			else
			{
				_pBindAdapter->getEpollServer()->debug(""send ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] close connection by peer."");
				return -1;
			}
		}

		if(iBytesSent > 0)
		{
			nowSendBufferSize += iBytesSent;

			if(isTcp())
			{
				_sendBuffer.moveHeader(iBytesSent);

				if (iBytesSent == (int)data.second)
				{
					_pBindAdapter->decreaseSendBufferSize();
				}
			}
			else
			{
				_sendBuffer.moveHeader(data.second);

				_pBindAdapter->decreaseSendBufferSize();

			}
		}

		//发送的数据小于需要发送的,break, 内核会再通知你的
		if (iBytesSent < (int)data.second)
		{
			break;
		}
	}

	//需要关闭链接
	if (_bClose && _sendBuffer.empty())
	{
		_pBindAdapter->getEpollServer()->debug(""send ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] close connection by user."");
		return -2;
	}

//	当出现队列积压的前提下, 且积压超过一定大小
//	每5秒检查一下积压情况, 连续12次(一分钟), 都是积压
//	且每个检查点, 积压长度都增加或者连续3次发送buffer字节小于1k, 就关闭连接, 主要避免极端情况

	size_t iBackPacketBuffLimit = _pBindAdapter->getBackPacketBuffLimit();
	if(_sendBuffer.getBufferLength() > iBackPacketBuffLimit)
	{
		if(_sendBufferSize == 0)
		{
			//开始积压
			_lastCheckTime = TNOW;
		}
		_sendBufferSize += nowSendBufferSize;

		if (TNOW - _lastCheckTime >= 5)
		{
			//如果持续有积压, 则每5秒检查一次
			_lastCheckTime = TNOW;

			_checkSend.push_back(make_pair(_sendBufferSize, nowLeftBufferSize));

			_sendBufferSize = 0;

			size_t iBackPacketBuffMin = _pBindAdapter->getBackPacketBuffMin();

			//连续3个5秒, 发送速度都极慢, 每5秒发送 < iBackPacketBuffMin, 认为连接有问题, 关闭之
			int left = 3;
			if ((int)_checkSend.size() >= left)
			{
				bool slow = true;
				for (int i = (int)_checkSend.size() - 1; i >= (int)(_checkSend.size() - left); i--)
				{
					//发送速度
					if (_checkSend[i].first > iBackPacketBuffMin)
					{
						slow = false;
						continue;
					}
				}

				if (slow)
				{
					ostringstream os;
					os << ""send ["" << _ip <<  "":"" << _port << ""] buffer queue send to slow, send size:"";

					for (int i = (int)_checkSend.size() - 1; i >= (int)(_checkSend.size() - left); i--)
					{
						os << "", "" << _checkSend[i].first;
					}

					_pBindAdapter->getEpollServer()->error(os.str());
					_sendBuffer.clearBuffers();
					return -5;
				}
			}

			//连续12个5秒, 都有积压现象, 检查
			if (_checkSend.size() >= 12)
			{
				bool accumulate = true;
				for (size_t i = _checkSend.size() - 1; i >= 1; i--) {
					//发送buffer 持续增加
					if (_checkSend[i].second < _checkSend[i - 1].second) {
						accumulate = false;
						break;
					}
				}

				//持续积压
				if (accumulate)
				{
					ostringstream os;
					os << ""send ["" << _ip <<  "":"" << _port << ""] buffer queue continues to accumulate data, queue size:"";

					for (size_t i = 0; i < _checkSend.size(); i++)
					{
						os << "", "" << _checkSend[i].second;
					}

					_pBindAdapter->getEpollServer()->error(os.str());
					_sendBuffer.clearBuffers();
					return -4;
				}

				_checkSend.erase(_checkSend.begin());
			}
		}
	}
	else
	{
		//无积压
		_sendBufferSize = 0;
		_lastCheckTime  = TNOW;
		_checkSend.clear();
	}

	return 0;

}


int TC_EpollServer::Connection::sendBufferDirect(const std::string& buff)
{
    _pBindAdapter->increaseSendBufferSize();
    
    if(getBindAdapter()->getEndpoint().isTcp())
    {
#if TAF_SSL
        if (getBindAdapter()->getEndpoint().isSSL())
        {
            //assert(_openssl->isHandshaked());
            
            int ret = _openssl->write(buff.c_str(), buff.length(), _sendBuffer);
            if (ret != 0)
            {
                _pBindAdapter->getEpollServer()->error(""[TC_EpollServer::Connection] send direct error! "" + TC_Common::tostr(ret));
                return -1; // should not happen
            }
    
        }
        else
#endif
        {
            _sendBuffer.addBuffer(buff);
        }

        return sendBuffer();
    }
    else
    {
        _pBindAdapter->getEpollServer()->error(""[TC_EpollServer::Connection] send direct not support udp! "");
        return -2;
    }
}

int TC_EpollServer::Connection::send(const shared_ptr<SendContext> &sc)
{
	assert(sc);

	_pBindAdapter->increaseSendBufferSize();

    if(getBindAdapter()->getEndpoint().isTcp())
    {
    #if TARS_SSL
        if (getBindAdapter()->getEndpoint().isSSL())
        {
            assert(_openssl->isHandshaked());

            int ret = _openssl->write(sc->buffer()->buffer(), sc->buffer()->length(), _sendBuffer);
            if (ret != 0) 
            {
                _pBindAdapter->getEpollServer()->error(""[TC_EpollServer::Connection] send ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] error:"" + _openssl->getErrMsg());

                return -1; // should not happen
            }
        }
        else
    #endif
        {
            _sendBuffer.addBuffer(sc->buffer());
        }

        return sendBuffer();
    }
    else
    {
        //注意udp, 回包时需要带上请求包的ip, port的
		int iRet = _sock.sendto((const void *) sc->buffer()->buffer(), sc->buffer()->length(), sc->ip(), sc->port(), 0);
        if (iRet < 0)
        {
            _pBindAdapter->getEpollServer()->error(""[TC_EpollServer::Connection] send udp ["" + _ip + "":"" + TC_Common::tostr(_port) + ""] error"");
            return -1;
        }
	}
    return 0;
}

bool TC_EpollServer::Connection::setRecvBuffer(size_t nSize)
{
    //only udp type needs to malloc
    if (!isTcp() && !_pRecvBuffer)
    {
        _nRecvBufferSize = nSize;

        _pRecvBuffer = new char[_nRecvBufferSize];
        if (!_pRecvBuffer)
        {
            throw TC_Exception(""adapter '"" + _pBindAdapter->getName() + ""' malloc udp receive buffer fail"");
        }
    }
    return true;
}

bool TC_EpollServer::Connection::setClose()
{
    _bClose = true;
    if (_sendBuffer.empty())
        return true;
    else
        return false;
}

////////////////////////////////////////////////////////////////
//
TC_EpollServer::ConnectionList::ConnectionList(TC_EpollServer::NetThread *pEpollServer)
: _pEpollServer(pEpollServer)
, _total(0)
, _free_size(0)
, _vConn(NULL)
, _lastTimeoutTime(0)
, _iConnectionMagic(0)
{
}

void TC_EpollServer::ConnectionList::init(uint32_t size, uint32_t iIndex)
{
    _lastTimeoutTime = TNOW;

    _total = size;

    _free_size = 0;

    //初始化链接链表
    if (_vConn) delete[] _vConn;

    //分配total+1个空间(多分配一个空间, 第一个空间其实无效)
    _vConn = new list_data[_total+1];

    _iConnectionMagic   = ((((uint32_t)_lastTimeoutTime) << 26) & (0xFFFFFFFF << 26)) + ((iIndex << 22) & (0xFFFFFFFF << 22));//((uint32_t)_lastTimeoutTime) << 20;

    //free从1开始分配, 这个值为uid, 0保留为管道用, epollwait根据0判断是否是管道消息
    for(uint32_t i = 1; i <= _total; i++)
    {
        _vConn[i].first = NULL;

        _free.push_back(i);

        ++_free_size;
    }
}

uint32_t TC_EpollServer::ConnectionList::getUniqId()
{
    TC_LockT<TC_ThreadMutex> lock(_mutex);

    uint32_t uid = _free.front();

    assert(uid > 0 && uid <= _total);

    _free.pop_front();

    --_free_size;

    return _iConnectionMagic | uid;
}

TC_EpollServer::Connection* TC_EpollServer::ConnectionList::get(uint32_t uid)
{
    uint32_t magi = uid & (0xFFFFFFFF << 22);
    uid           = uid & (0x7FFFFFFF >> 9);

    if (magi != _iConnectionMagic) return NULL;

    return _vConn[uid].first;
}

void TC_EpollServer::ConnectionList::add(Connection *cPtr, time_t iTimeOutStamp)
{
    TC_LockT<TC_ThreadMutex> lock(_mutex);

    uint32_t muid = cPtr->getId();
    uint32_t magi = muid & (0xFFFFFFFF << 22);
    uint32_t uid  = muid & (0x7FFFFFFF >> 9);

    assert(magi == _iConnectionMagic && uid > 0 && uid <= _total && !_vConn[uid].first);

    _vConn[uid] = make_pair(cPtr, _tl.insert(make_pair(iTimeOutStamp, uid)));
}

void TC_EpollServer::ConnectionList::refresh(uint32_t uid, time_t iTimeOutStamp)
{
    TC_LockT<TC_ThreadMutex> lock(_mutex);

    uint32_t magi = uid & (0xFFFFFFFF << 22);
    uid           = uid & (0x7FFFFFFF >> 9);

    assert(magi == _iConnectionMagic && uid > 0 && uid <= _total && _vConn[uid].first);

    if(iTimeOutStamp - _vConn[uid].first->_iLastRefreshTime < 1)
    {
        return;
    }

    _vConn[uid].first->_iLastRefreshTime = iTimeOutStamp;

    //删除超时链表
    _tl.erase(_vConn[uid].second);

    _vConn[uid].second = _tl.insert(make_pair(iTimeOutStamp, uid));
}

void TC_EpollServer::ConnectionList::checkTimeout(time_t iCurTime)
{
    //至少1s才能检查一次
    if(iCurTime - _lastTimeoutTime < 1)
    {
        return;
    }

    _lastTimeoutTime = iCurTime;

    TC_LockT<TC_ThreadMutex> lock(_mutex);

    multimap<time_t, uint32_t>::iterator it = _tl.begin();

    while(it != _tl.end())
    {
        //已经检查到当前时间点了, 后续不用在检查了
        if(it->first > iCurTime)
        {
            break;
        }

        uint32_t uid = it->second;

        ++it;

        //udp的监听端口, 不做处理
        if(_vConn[uid].first->getListenfd() == -1)
        {
            continue;
        }

        //超时关闭
        _pEpollServer->delConnection(_vConn[uid].first, false, EM_SERVER_TIMEOUT_CLOSE);

        //从链表中删除
        _del(uid);
    }

    if(_pEpollServer->isEmptyConnCheck())
    {
        it = _tl.begin();
        while(it != _tl.end())
        {
            uint32_t uid = it->second;

            //遍历所有的空连接
            if(_vConn[uid].first->isEmptyConn())
            {
                //获取空连接的超时时间点
                time_t iEmptyTimeout = (it->first - _vConn[uid].first->getTimeout()) + (_pEpollServer->getEmptyConnTimeout()/1000);

                //已经检查到当前时间点了, 后续不用在检查了
                if(iEmptyTimeout > iCurTime)
                {
                    break;
                }

                //udp的监听端口, 不做处理
                if(_vConn[uid].first->getListenfd() == -1)
                {
                    ++it;
                    continue;
                }

                //超时关闭
                _pEpollServer->delConnection(_vConn[uid].first, false, EM_SERVER_TIMEOUT_CLOSE);

                //从链表中删除
                _del(uid);
            }

            ++it;
        }
    }
}

vector<TC_EpollServer::ConnStatus> TC_EpollServer::ConnectionList::getConnStatus(int lfd)
{
    vector<TC_EpollServer::ConnStatus> v;

	TC_LockT<TC_ThreadMutex> lock(_mutex);

    for(size_t i = 1; i <= _total; i++)
    {
        //是当前监听端口的连接
        if(_vConn[i].first != NULL && _vConn[i].first->getListenfd() == lfd)
        {
            TC_EpollServer::ConnStatus cs;

            cs.iLastRefreshTime = _vConn[i].first->_iLastRefreshTime;
            cs.ip               = _vConn[i].first->getIp();
            cs.port             = _vConn[i].first->getPort();
            cs.timeout          = _vConn[i].first->getTimeout();
            cs.uid              = _vConn[i].first->getId();
            cs.recvBufferSize   = _vConn[i].first->getRecvBuffer().getBufferLength();
            cs.sendBufferSize   = _vConn[i].first->getSendBuffer().getBufferLength();

            v.push_back(cs);
        }
    }

    return v;
}

void TC_EpollServer::ConnectionList::del(uint32_t uid)
{
    TC_LockT<TC_ThreadMutex> lock(_mutex);

    uint32_t magi = uid & (0xFFFFFFFF << 22);
    uid           = uid & (0x7FFFFFFF >> 9);

    assert(magi == _iConnectionMagic && uid > 0 && uid <= _total && _vConn[uid].first);

    _del(uid);
}

void TC_EpollServer::ConnectionList::_del(uint32_t uid)
{
    assert(uid > 0 && uid <= _total && _vConn[uid].first);

    _tl.erase(_vConn[uid].second);

    delete _vConn[uid].first;

    _vConn[uid].first = NULL;

    _free.push_back(uid);

    ++_free_size;
}

size_t TC_EpollServer::ConnectionList::size()
{
    TC_LockT<TC_ThreadMutex> lock(_mutex);

    return _total - _free_size;
}

//////////////////////////////NetThread//////////////////////////////////
TC_EpollServer::NetThread::NetThread(TC_EpollServer *epollServer, int threadIndex)
: _epollServer(epollServer)
, _threadIndex(threadIndex)
, _bTerminate(false)
, _list(this)
, _bEmptyConnAttackCheck(false)
, _iEmptyCheckTimeout(MIN_EMPTY_CONN_TIMEOUT)
, _nUdpRecvBufferSize(DEFAULT_RECV_BUFFERSIZE)
{
    _epoller.create(10240);

    _notify.init(&_epoller);
    _notify.add(_notify.notifyFd());
}

TC_EpollServer::NetThread::~NetThread()
{
}

void TC_EpollServer::NetThread::debug(const string &s) const
{
    _epollServer->debug(s);
}

void TC_EpollServer::NetThread::info(const string &s) const
{
    _epollServer->info(s);
}

void TC_EpollServer::NetThread::tars(const string &s) const
{
	_epollServer->tars(s);
}

void TC_EpollServer::NetThread::error(const string &s) const
{
    _epollServer->error(s);
}

void TC_EpollServer::NetThread::enAntiEmptyConnAttack(bool bEnable)
{
    _bEmptyConnAttackCheck = bEnable;
}

void TC_EpollServer::NetThread::setEmptyConnTimeout(int timeout)
{
    _iEmptyCheckTimeout = (timeout >= MIN_EMPTY_CONN_TIMEOUT) ? timeout : MIN_EMPTY_CONN_TIMEOUT;
}

void TC_EpollServer::NetThread::setUdpRecvBufferSize(size_t nSize)
{
    _nUdpRecvBufferSize = (nSize >= 8192 && nSize <= DEFAULT_RECV_BUFFERSIZE) ? nSize : DEFAULT_RECV_BUFFERSIZE;
}

bool TC_EpollServer::NetThread::isEmptyConnCheck() const
{
    return _bEmptyConnAttackCheck;
}

int TC_EpollServer::NetThread::getEmptyConnTimeout() const
{
    return _iEmptyCheckTimeout;
}

void TC_EpollServer::NetThread::createEpoll(uint32_t maxAllConn)
{
    _list.init((uint32_t)maxAllConn, _threadIndex + 1);
}

void TC_EpollServer::NetThread::initUdp(const unordered_map<int, TC_EpollServer::BindAdapterPtr> &listeners)
{
    //监听socket
    auto it = listeners.begin();

    while (it != listeners.end())
    {
        if (!it->second->getEndpoint().isTcp())
        {
            Connection *cPtr = new Connection(it->second.get(), it->first);
            //udp分配接收buffer
            cPtr->setRecvBuffer(_nUdpRecvBufferSize);

            //addUdpConnection(cPtr);
            _epollServer->addConnection(cPtr, it->first, UDP_CONNECTION);
        }

        ++it;
    }
}

void TC_EpollServer::NetThread::terminate()
{
    _bTerminate = true;

    _notify.notify();
}

void TC_EpollServer::NetThread::addTcpConnection(TC_EpollServer::Connection *cPtr)
{
    uint32_t uid = _list.getUniqId();

    cPtr->init(uid);

    _list.add(cPtr, cPtr->getTimeout() + TNOW);

    cPtr->getBindAdapter()->increaseNowConnection();

#if TARS_SSL
    if (cPtr->getBindAdapter()->getEndpoint().isSSL())
    {
        cPtr->getBindAdapter()->getEpollServer()->info(""[TARS][addTcpConnection ssl connection"");

        // 分配ssl对象, ctxName 放在obj proxy里
        cPtr->_openssl = TC_OpenSSL::newSSL(cPtr->getBindAdapter()->_ctx);
        if (!cPtr->_openssl)
        {
            cPtr->getBindAdapter()->getEpollServer()->error(""[TARS][SSL_accept not find server cert"");
	        cPtr->close();
            return;
        }

        cPtr->_openssl->recvBuffer()->setConnection(cPtr);
        cPtr->_openssl->init(true);
        cPtr->_openssl->setReadBufferSize(1024 * 8);
        cPtr->_openssl->setWriteBufferSize(1024 * 8);

        int ret = cPtr->_openssl->doHandshake(cPtr->_sendBuffer);
        if (ret != 0)
        {
            cPtr->getBindAdapter()->getEpollServer()->error(""[TARS][SSL_accept "" + cPtr->getBindAdapter()->getEndpoint().toString() + "" error: "" + cPtr->_openssl->getErrMsg());
	        cPtr->close();
            return;
        }

        // send the encrypt data from write buffer
        if (!cPtr->_sendBuffer.empty())
        {
            cPtr->sendBuffer();
        }
    }
#endif
    //注意epoll add必须放在最后, 否则可能导致执行完, 才调用上面语句
    _epoller.add(cPtr->getfd(), cPtr->getId(), EPOLLIN | EPOLLOUT);
}

void TC_EpollServer::NetThread::addUdpConnection(TC_EpollServer::Connection *cPtr)
{
    uint32_t uid = _list.getUniqId();

    cPtr->init(uid);

    _list.add(cPtr, cPtr->getTimeout() + TNOW);

    _epoller.add(cPtr->getfd(), cPtr->getId(), EPOLLIN | EPOLLOUT);
}

vector<TC_EpollServer::ConnStatus> TC_EpollServer::NetThread::getConnStatus(int lfd)
{
    return _list.getConnStatus(lfd);
}

void TC_EpollServer::NetThread::delConnection(TC_EpollServer::Connection *cPtr, bool bEraseList, EM_CLOSE_T closeType)
{
    //如果是TCP的连接才真正的关闭连接
    if (cPtr->getListenfd() != -1)
    {
        BindAdapterPtr adapter = cPtr->getBindAdapter();

        //false的情况,是超时被主动删除
        if(!bEraseList)
        {
            tars(""timeout ["" + cPtr->getIp() + "":"" + TC_Common::tostr(cPtr->getPort()) + ""] del from list"");
        }

        uint32_t uid = cPtr->getId();

        //构造一个tagRecvData，通知业务该连接的关闭事件
        shared_ptr<RecvContext> recv   = std::make_shared<RecvContext>(uid, cPtr->getIp(), cPtr->getPort(), cPtr->getfd(), adapter, true, (int)closeType);

        //如果是merge模式，则close直接交给网络线程处理
        if (_epollServer->isMergeHandleNetThread())
        {
            cPtr->insertRecvQueue(recv);
        }
        else
        {
            cPtr->getBindAdapter()->insertRecvQueue(recv);
        }

        //从epoller删除句柄放在close之前, 否则重用socket时会有问题
        _epoller.del(cPtr->getfd(), uid, 0);

        cPtr->close();

        //对于超时检查, 由于锁的原因, 在这里不从链表中删除
        if(bEraseList)
        {
            _list.del(uid);
        }
        
        adapter->decreaseNowConnection();
    }
}

void TC_EpollServer::NetThread::notify()
{
    _notify.notify();
}

void TC_EpollServer::NetThread::close(const shared_ptr<RecvContext> &data)
{
    shared_ptr<SendContext> send = data->createCloseContext();

    _sbuffer.push_back(send);

//	通知epoll响应, 关闭连接
    _notify.notify();
}

void TC_EpollServer::NetThread::send(const shared_ptr<SendContext> &data)
{
    if(_threadId == std::this_thread::get_id()) {
        //发送包线程和网络线程是同一个线程,直接发送即可
        Connection *cPtr = getConnectionPtr(data->uid());
        if(cPtr)
        {
            cPtr->send(data);
        }
    }
    else {
        //发送包线程和网络线程不是同一个线程, 需要先放队列, 再唤醒网络线程去发送
        _sbuffer.push_back(data);

        //通知epoll响应, 有数据要发送
        if (!_notifySignal) {
            _notifySignal = true;
            _notify.notify();
        }
    }
}

void TC_EpollServer::NetThread::processPipe()
{
    _notifySignal = false;

    while(!_sbuffer.empty())
    {
        shared_ptr<SendContext> sc = _sbuffer.front();
        Connection *cPtr = getConnectionPtr(sc->uid());

        if (!cPtr)
        {
            _sbuffer.pop_front();
            continue;
        }
        switch (sc->cmd())
        {
            case 'c':
            {
                if (cPtr->setClose())
                {
                    delConnection(cPtr, true, EM_SERVER_CLOSE);
                }
                break;
            }
            case 's':
            {
                int ret = 0;
#if TARS_SSL
                if (cPtr->getBindAdapter()->getEndpoint().isSSL()) {
                    if (!cPtr->_openssl->isHandshaked()) {
                        return;
                    }
                }
                ret = cPtr->send(sc);
#else
                ret = cPtr->send(sc);
#endif
                if (ret < 0)
                {
                    delConnection(cPtr, true, (ret == -1) ? EM_CLIENT_CLOSE : EM_SERVER_CLOSE);
                }
                else
                {
                    _list.refresh(sc->uid(), cPtr->getTimeout() + TNOW);
                }
                break;
            }
            default:
                assert(false);
        }
        _sbuffer.pop_front();
    }
}

void TC_EpollServer::NetThread::processNet(const epoll_event &ev)
{
    uint32_t uid = TC_Epoller::getU32(ev, false);

    Connection *cPtr = getConnectionPtr(uid);

    if(!cPtr)
    {
        debug(""TC_EpollServer::NetThread::processNet connection["" + TC_Common::tostr(uid) + ""] not exists."");
        return;
    }

    if (TC_Epoller::errorEvent(ev))
    {
        delConnection(cPtr, true, EM_SERVER_CLOSE);
        return;
    }

    if (TC_Epoller::readEvent(ev))
    {
        int ret = cPtr->recv();
        if (ret < 0)
        {
            delConnection(cPtr, true, EM_CLIENT_CLOSE);

            return;
        }
    }

    if (TC_Epoller::writeEvent(ev))
    {
        int ret = cPtr->sendBuffer();
        if (ret < 0)
        {
            delConnection(cPtr, true, (ret == -1) ? EM_CLIENT_CLOSE : EM_SERVER_CLOSE);

            return;
        }
    }

    _list.refresh(uid, cPtr->getTimeout() + TNOW);
}

void TC_EpollServer::NetThread::run()
{
    _threadId = std::this_thread::get_id();

    if(_epollServer->isMergeHandleNetThread()) {

        vector<TC_EpollServer::BindAdapterPtr> adapters = _epollServer->getBindAdapters();

        for (auto adapter : adapters)
        {
            adapter->getHandle(_threadIndex)->setNetThread(this);
            adapter->getHandle(_threadIndex)->initialize();
        }
    }

    //循环监听网路连接请求
    while(!_bTerminate)
    {
        _list.checkTimeout(TNOW);

        int iEvNum = _epoller.wait(1000);
        //没有网络事件
        if (iEvNum == 0)
        {
            //在这里加上心跳逻辑，获取所有的bindAdpator,然后发心跳
            if (_epollServer->isMergeHandleNetThread()) 
            {
                vector<TC_EpollServer::BindAdapterPtr> adapters = _epollServer->getBindAdapters();
                for (auto adapter : adapters)
                {
                    adapter->getHandle(_threadIndex)->heartbeat();
                }
            }
        }

        if (_bTerminate)
            break;

        for (int i = 0; i < iEvNum; ++i)
        {
            try
            {
                const epoll_event &ev = _epoller.get(i);

                uint32_t fd = TC_Epoller::getU32(ev, false);

                if (fd == (uint32_t)_notify.notifyFd())
                {
                    //检查是否是通知消息
                    processPipe();
                }
                else
                {
                    processNet(ev);
                }
            }
            catch (exception &ex)
            {
                error(""run exception:"" + string(ex.what()));
            }
        }
    }
}

//size_t TC_EpollServer::NetThread::getSendRspSize()
//{
//    return _sbuffer.size();
//}
//////////////////////////////////////////////////////////////
TC_EpollServer::TC_EpollServer(unsigned int iNetThreadNum)
: _netThreadNum(iNetThreadNum)
, _bTerminate(false)
, _handleStarted(false)
, _pLocalLogger(NULL)
, _acceptFunc(NULL)
{
#if TARGET_PLATFORM_WINDOWS    
    WSADATA wsadata;
    WSAStartup(MAKEWORD(2, 2), &wsadata);
#endif

    if(_netThreadNum < 1)
    {
        _netThreadNum = 1;
    }

    //网络线程的配置数目不能15个
    if(_netThreadNum > 15)
    {
        _netThreadNum = 15;
    }

    //创建epoll
    _epoller.create(10240);

    _notify.init(&_epoller);
    _notify.add(_notify.notifyFd());

    for (size_t i = 0; i < _netThreadNum; ++i)
    {
        TC_EpollServer::NetThread* netThreads = new TC_EpollServer::NetThread(this, i);
        _netThreads.push_back(netThreads);
    }
}

TC_EpollServer::~TC_EpollServer()
{
    terminate();

    for (size_t i = 0; i < _netThreadNum; ++i)
    {
        delete _netThreads[i];
    }

    _netThreads.clear();

    _netThreadNum = 0;

    auto it = _listeners.begin();

    while (it != _listeners.end())
    {
        TC_Port::closeSocket(it->first);
        ++it;
    }
    _listeners.clear();

#if TARGET_PLATFORM_WINDOWS    
    WSACleanup();
#endif    
}

void TC_EpollServer::applicationCallback(TC_EpollServer *epollServer)
{
}

bool TC_EpollServer::accept(int fd, int domain)
{
    struct sockaddr_in stSockAddr4;
    struct ::sockaddr_in6 stSockAddr6;

    socklen_t iSockAddrSize = (AF_INET6 == domain) ? sizeof(::sockaddr_in6) : sizeof(sockaddr_in);
    struct sockaddr* stSockAddr = (AF_INET6 == domain) ? (struct sockaddr*) & stSockAddr6 : (struct sockaddr*) & stSockAddr4;

    TC_Socket cs;

    cs.setOwner(false);

    //接收连接
    TC_Socket s;

    s.init(fd, false, domain);
    int iRetCode = s.accept(cs, (struct sockaddr *)stSockAddr, iSockAddrSize);
    if (iRetCode > 0)
    {
        string ip;
        uint16_t port;

        char sAddr[INET6_ADDRSTRLEN] = ""\\0"";

        inet_ntop(domain, (AF_INET6 == domain) ? ( void *)&stSockAddr6.sin6_addr : ( void *)&stSockAddr4.sin_addr, sAddr, sizeof(sAddr));
        port = (AF_INET6 == domain) ? ntohs(stSockAddr6.sin6_port) : ntohs(stSockAddr4.sin_port);
        ip = sAddr;
        
        debug(""accept ["" + ip + "":"" + TC_Common::tostr(port) + ""] ["" + TC_Common::tostr(cs.getfd()) + ""] incomming"");

        if (!_listeners[fd]->isIpAllow(ip))
        {
            debug(""accept ["" + ip + "":"" + TC_Common::tostr(port) + ""] ["" + TC_Common::tostr(cs.getfd()) + ""] not allowed"");

            cs.close();

            return true;
        }

        if (_listeners[fd]->isLimitMaxConnection())
        {
            error(""accept ["" + ip + "":"" + TC_Common::tostr(port) + ""]["" + TC_Common::tostr(cs.getfd()) + ""] beyond max connection:"" + TC_Common::tostr(_listeners[fd]->getMaxConns()));
            cs.close();

            return true;
        }

        cs.setblock(false);
        cs.setKeepAlive();
        cs.setTcpNoDelay();
        cs.setCloseWaitDefault();

        int timeout = _listeners[fd]->getEndpoint().getTimeout() / 1000;

        Connection *cPtr = new Connection(_listeners[fd].get(), fd, (timeout < 2 ? 2 : timeout), cs.getfd(), ip, port);

        //过滤连接首个数据包包头
        cPtr->setHeaderFilterLen((int)_listeners[fd]->getHeaderFilterLen());

        addConnection(cPtr, cs.getfd(), TCP_CONNECTION);

        return true;
    }
    else
    {
        // //直到发生EAGAIN才不继续accept
        // if (TC_Socket::isPending())
        // {
        //     return false;
        // }

        return false;
    }
    return true;
}

void TC_EpollServer::waitForShutdown()
{

    if(!isMergeHandleNetThread())
        startHandle();

    createEpoll();

    for (size_t i = 0; i < _netThreadNum; ++i)
    {
        _netThreads[i]->start();
    }

    int64_t iLastCheckTime = TNOWMS;

    while (!_bTerminate)
    {
        int iEvNum = _epoller.wait(300);

        if (_bTerminate)
            break;

        if(TNOWMS - iLastCheckTime > 1000) {
            try { _hf(this); } catch(...) {}
            iLastCheckTime = TNOWMS;
        }

        for (int i = 0; i < iEvNum; ++i)
        {
            try
            {
                const epoll_event &ev = _epoller.get(i);

                uint32_t fd = TC_Epoller::getU32(ev, false);

                auto it = _listeners.find(fd);

                if (it != _listeners.end())
                {
                    //manualListen 会进入这个场景
                    if (TC_Epoller::writeEvent(ev))
                    {
                        TC_Socket s;
                        s.init(fd, false);
                        s.listen(1024);

                        debug(""run listen fd: "" + TC_Common::tostr(fd));
                    }

                    //监听端口有请求
                    if (TC_Epoller::readEvent(ev))
                    {
#if TARGET_PLATFORM_LINUX || TARGET_PLATFORM_IOS

                        bool ret;
                        do
                        {

                            ret = accept(fd, it->second->_ep.isIPv6() ? AF_INET6 : AF_INET);
                        } while (ret);
#else

                        accept(fd, it->second->_ep.isIPv6() ? AF_INET6 : AF_INET);
#endif
                    }
                }
            }
            catch (exception &ex)
            {
                error(""run exception:"" + string(ex.what()));
            }
            catch (...)
            {
                error(""TC_EpollServer::waitForShutdown unknown error"");
            }
        }
    }

    for (size_t i = 0; i < _netThreads.size(); ++i)
    {
        if (_netThreads[i]->isAlive())
        {
            _netThreads[i]->terminate();

            _netThreads[i]->getThreadControl().join();
        }
    }
    
}

void TC_EpollServer::terminate()
{
    if (!_bTerminate)
    {
        _bTerminate = true;

        //停掉处理线程
        stopThread();

        //停掉主线程(waitForShutdown)
        _notify.notify();
    }
}

void TC_EpollServer::enAntiEmptyConnAttack(bool bEnable)
{
    for(size_t i = 0; i < _netThreads.size(); ++i)
    {
        _netThreads[i]->enAntiEmptyConnAttack(bEnable);
    }
}

void TC_EpollServer::setEmptyConnTimeout(int timeout)
{
    for(size_t i = 0; i < _netThreads.size(); ++i)
    {
        _netThreads[i]->setEmptyConnTimeout(timeout);
    }
}

void TC_EpollServer::bind(const TC_Endpoint &ep, TC_Socket &s, bool manualListen)
{
#if TARGET_PLATFORM_WINDOWS
    int type = ep.isIPv6() ? AF_INET6 : AF_INET;
#else
    int type = ep.isUnixLocal() ? AF_LOCAL : ep.isIPv6() ? AF_INET6 : AF_INET;
#endif

#if TARGET_PLATFORM_LINUX
    if (ep.isTcp())
    {
        s.createSocket(SOCK_STREAM | SOCK_CLOEXEC, type);
    }
    else
    {
        s.createSocket(SOCK_DGRAM | SOCK_CLOEXEC, type);
    }
#else
	if (ep.isTcp())
	{
		s.createSocket(SOCK_STREAM, type);
	}
	else
	{
		s.createSocket(SOCK_DGRAM, type);
	}
#endif

#if TARGET_PLATFORM_WINDOWS
    s.bind(ep.getHost(), ep.getPort());
    if (ep.isTcp())
#else
    if (ep.isUnixLocal())
    {
        s.bind(ep.getHost().c_str());
    }
    else
    {
        s.bind(ep.getHost(), ep.getPort());
    }
    if (ep.isTcp() && !ep.isUnixLocal())

#endif
    {
        if(!manualListen)
        {
            //手工监听
            s.listen(10240);
        }
        s.setKeepAlive();
        s.setTcpNoDelay();

        //不要设置close wait否则http服务回包主动关闭连接会有问题
        s.setNoCloseWait();
    }

    s.setblock(false);
}

int TC_EpollServer::bind(BindAdapterPtr &lsPtr)
{
    auto it = _listeners.begin();

    while (it != _listeners.end())
    {
        if (it->second->getName() == lsPtr->getName())
        {
            throw TC_Exception(""bind name '"" + lsPtr->getName() + ""' conflicts."");
        }
        ++it;
    }

    const TC_Endpoint &ep = lsPtr->getEndpoint();

    TC_Socket &s = lsPtr->getSocket();

    bind(ep, s, lsPtr->isManualListen());

    _listeners[s.getfd()] = lsPtr;

    _bindAdapters.push_back(lsPtr);

    return s.getfd();
}

void TC_EpollServer::addConnection(TC_EpollServer::Connection *cPtr, int fd, TC_EpollServer::CONN_TYPE iType)
{
    TC_EpollServer::NetThread* netThread = getNetThreadOfFd(fd);

    if(iType == TCP_CONNECTION)
    {
        netThread->addTcpConnection(cPtr);
    }
    else
    {
        netThread->addUdpConnection(cPtr);
    }
    // 回调
    if (_acceptFunc != NULL)
    {
        _acceptFunc(cPtr);
    }
}

void TC_EpollServer::startHandle()
{
    if(!this->isMergeHandleNetThread())
    {
        if (!_handleStarted)
        {
            _handleStarted = true;

            for (auto & bindAdapter : _bindAdapters)
            {
                const vector<TC_EpollServer::HandlePtr> & hds = bindAdapter->getHandles();

                for (uint32_t i = 0; i < hds.size(); ++i) {
                    if (!hds[i]->isAlive()) {
                        hds[i]->start();
                    }
                }
            }
        }
    }
}

void TC_EpollServer::stopThread()
{
    if(!this->isMergeHandleNetThread())
    {
        for (auto & bindAdapter : _bindAdapters)
        {
            const vector<TC_EpollServer::HandlePtr> & hds = bindAdapter->getHandles();

            //把处理线程都唤醒
            if(!bindAdapter->isQueueMode()) {
                bindAdapter->notifyHandle(0);
            }
            else {
                for (uint32_t i = 0; i < hds.size(); i++) {
                    bindAdapter->notifyHandle(i);
                }
            }

            for (uint32_t i = 0; i < hds.size(); ++i) {
                if (hds[i]->isAlive()) {
                    hds[i]->getThreadControl().join();
                }
            }
        }
    }
}

void TC_EpollServer::createEpoll()
{

    uint32_t maxAllConn = 0;

    //监听socket
    auto it = _listeners.begin();

    while (it != _listeners.end())
    {
        if (it->second->getEndpoint().isTcp())
        {
            //获取最大连接数
            maxAllConn += it->second->getMaxConns();

            _epoller.add(it->first, it->first, EPOLLIN);
        }
        else
        {
            maxAllConn++;
        }

        ++it;
    }

    if (maxAllConn >= (1 << 22))
    {
        error(""createEpoll connection num: "" + TC_Common::tostr(maxAllConn) + "" >= "" + TC_Common::tostr(1 << 22));
        maxAllConn = (1 << 22) - 1;
    }

    for (size_t i = 0; i < _netThreads.size(); ++i)
    {
        _netThreads[i]->createEpoll(maxAllConn);
    }

    //必须先等所有网络线程调用createEpoll()，初始化list后，才能调用initUdp()
    for (size_t i = 0; i < _netThreads.size(); ++i)
    {
        _netThreads[i]->initUdp(_listeners);
    }
}

TC_EpollServer::BindAdapterPtr TC_EpollServer::getBindAdapter(const string &sName)
{
    auto it = _listeners.begin();

    while (it != _listeners.end())
    {
        if (it->second->getName() == sName)
        {
            return it->second;
        }

        ++it;
    }
    return NULL;
}

vector<TC_EpollServer::BindAdapterPtr> TC_EpollServer::getBindAdapters()
{
    return this->_bindAdapters;
}

void TC_EpollServer::close(const shared_ptr<TC_EpollServer::RecvContext> &data)
{
    TC_EpollServer::NetThread *netThread = getNetThreadOfFd(data->fd());

    netThread->close(data);
}

void TC_EpollServer::send(const shared_ptr<SendContext> &data)
{
    TC_EpollServer::NetThread *netThread = getNetThreadOfFd(data->fd());

    netThread->send(data);
}

void TC_EpollServer::debug(const string &s) const
{
    if(_pLocalLogger)
    {
        _pLocalLogger->debug() << ""[TARS]"" << s << endl;
    }
}

void TC_EpollServer::info(const string &s) const
{
    if(_pLocalLogger)
    {
        _pLocalLogger->info() << ""[TARS]"" << s << endl;
    }
}

void TC_EpollServer::tars(const string &s) const
{
	if(_pLocalLogger)
	{
		_pLocalLogger->tars() << ""[TARS]"" << s << endl;
	}
}

void TC_EpollServer::error(const string &s) const
{
    if(_pLocalLogger)
    {
        _pLocalLogger->error() << ""[TARS]"" << s << endl;
    }
}

vector<TC_EpollServer::ConnStatus> TC_EpollServer::getConnStatus(int lfd)
{
    vector<TC_EpollServer::ConnStatus> vConnStatus;
    for(size_t i = 0; i < _netThreads.size(); ++i)
    {
        vector<TC_EpollServer::ConnStatus> tmp = _netThreads[i]->getConnStatus(lfd);
        for(size_t k = 0; k < tmp.size(); ++k)
        {
            vConnStatus.push_back(tmp[k]);
        }
    }
    return vConnStatus;
}

unordered_map<int, TC_EpollServer::BindAdapterPtr> TC_EpollServer::getListenSocketInfo()
{
    return _listeners;
}

size_t TC_EpollServer::getConnectionCount()
{
    size_t iConnTotal = 0;
    for(size_t i = 0; i < _netThreads.size(); ++i)
    {
        iConnTotal += _netThreads[i]->getConnectionCount();
    }
    return iConnTotal;
}

size_t TC_EpollServer::getLogicThreadNum()
{
    if(this->isMergeHandleNetThread())
    {
        return this->_netThreadNum;
    }
    else
    {

        size_t iNum = 0;

        for (auto & bindAdapter : _bindAdapters) {
            iNum += bindAdapter->getHandles().size();
        }
        return iNum;
    }
}

}
",16358,True,2967.9862106820347,median
"/* Copyright (c) 2015-2017 The Khronos Group Inc.
 * Copyright (c) 2015-2017 Valve Corporation
 * Copyright (c) 2015-2017 LunarG, Inc.
 * Copyright (C) 2015-2017 Google Inc.
 *
 * 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.
 *
 * Author: Chris Forbes <chrisf@ijw.co.nz>
 */

#include <cinttypes>
#include <cassert>
#include <vector>
#include <unordered_map>
#include <string>
#include <sstream>
#include <SPIRV/spirv.hpp>
#include ""vk_loader_platform.h""
#include ""vk_enum_string_helper.h""
#include ""vk_layer_table.h""
#include ""vk_layer_data.h""
#include ""vk_layer_extension_utils.h""
#include ""vk_layer_utils.h""
#include ""core_validation.h""
#include ""core_validation_types.h""
#include ""shader_validation.h""
#include ""spirv-tools/libspirv.h""

enum FORMAT_TYPE {
    FORMAT_TYPE_FLOAT = 1,  // UNORM, SNORM, FLOAT, USCALED, SSCALED, SRGB -- anything we consider float in the shader
    FORMAT_TYPE_SINT = 2,
    FORMAT_TYPE_UINT = 4,
};

typedef std::pair<unsigned, unsigned> location_t;

struct interface_var {
    uint32_t id;
    uint32_t type_id;
    uint32_t offset;
    bool is_patch;
    bool is_block_member;
    bool is_relaxed_precision;
    // TODO: collect the name, too? Isn't required to be present.
};

struct shader_stage_attributes {
    char const *const name;
    bool arrayed_input;
    bool arrayed_output;
};

static shader_stage_attributes shader_stage_attribs[] = {
    {""vertex shader"", false, false},  {""tessellation control shader"", true, true}, {""tessellation evaluation shader"", true, false},
    {""geometry shader"", true, false}, {""fragment shader"", false, false},
};

// SPIRV utility functions
void shader_module::build_def_index() {
    for (auto insn : *this) {
        switch (insn.opcode()) {
            // Types
            case spv::OpTypeVoid:
            case spv::OpTypeBool:
            case spv::OpTypeInt:
            case spv::OpTypeFloat:
            case spv::OpTypeVector:
            case spv::OpTypeMatrix:
            case spv::OpTypeImage:
            case spv::OpTypeSampler:
            case spv::OpTypeSampledImage:
            case spv::OpTypeArray:
            case spv::OpTypeRuntimeArray:
            case spv::OpTypeStruct:
            case spv::OpTypeOpaque:
            case spv::OpTypePointer:
            case spv::OpTypeFunction:
            case spv::OpTypeEvent:
            case spv::OpTypeDeviceEvent:
            case spv::OpTypeReserveId:
            case spv::OpTypeQueue:
            case spv::OpTypePipe:
                def_index[insn.word(1)] = insn.offset();
                break;

                // Fixed constants
            case spv::OpConstantTrue:
            case spv::OpConstantFalse:
            case spv::OpConstant:
            case spv::OpConstantComposite:
            case spv::OpConstantSampler:
            case spv::OpConstantNull:
                def_index[insn.word(2)] = insn.offset();
                break;

                // Specialization constants
            case spv::OpSpecConstantTrue:
            case spv::OpSpecConstantFalse:
            case spv::OpSpecConstant:
            case spv::OpSpecConstantComposite:
            case spv::OpSpecConstantOp:
                def_index[insn.word(2)] = insn.offset();
                break;

                // Variables
            case spv::OpVariable:
                def_index[insn.word(2)] = insn.offset();
                break;

                // Functions
            case spv::OpFunction:
                def_index[insn.word(2)] = insn.offset();
                break;

            default:
                // We don't care about any other defs for now.
                break;
        }
    }
}

static spirv_inst_iter find_entrypoint(shader_module const *src, char const *name, VkShaderStageFlagBits stageBits) {
    for (auto insn : *src) {
        if (insn.opcode() == spv::OpEntryPoint) {
            auto entrypointName = (char const *)&insn.word(3);
            auto entrypointStageBits = 1u << insn.word(1);

            if (!strcmp(entrypointName, name) && (entrypointStageBits & stageBits)) {
                return insn;
            }
        }
    }

    return src->end();
}

static char const *storage_class_name(unsigned sc) {
    switch (sc) {
        case spv::StorageClassInput:
            return ""input"";
        case spv::StorageClassOutput:
            return ""output"";
        case spv::StorageClassUniformConstant:
            return ""const uniform"";
        case spv::StorageClassUniform:
            return ""uniform"";
        case spv::StorageClassWorkgroup:
            return ""workgroup local"";
        case spv::StorageClassCrossWorkgroup:
            return ""workgroup global"";
        case spv::StorageClassPrivate:
            return ""private global"";
        case spv::StorageClassFunction:
            return ""function"";
        case spv::StorageClassGeneric:
            return ""generic"";
        case spv::StorageClassAtomicCounter:
            return ""atomic counter"";
        case spv::StorageClassImage:
            return ""image"";
        case spv::StorageClassPushConstant:
            return ""push constant"";
        default:
            return ""unknown"";
    }
}

// Get the value of an integral constant
unsigned get_constant_value(shader_module const *src, unsigned id) {
    auto value = src->get_def(id);
    assert(value != src->end());

    if (value.opcode() != spv::OpConstant) {
        // TODO: Either ensure that the specialization transform is already performed on a module we're
        //       considering here, OR -- specialize on the fly now.
        return 1;
    }

    return value.word(3);
}

static void describe_type_inner(std::ostringstream &ss, shader_module const *src, unsigned type) {
    auto insn = src->get_def(type);
    assert(insn != src->end());

    switch (insn.opcode()) {
        case spv::OpTypeBool:
            ss << ""bool"";
            break;
        case spv::OpTypeInt:
            ss << (insn.word(3) ? 's' : 'u') << ""int"" << insn.word(2);
            break;
        case spv::OpTypeFloat:
            ss << ""float"" << insn.word(2);
            break;
        case spv::OpTypeVector:
            ss << ""vec"" << insn.word(3) << "" of "";
            describe_type_inner(ss, src, insn.word(2));
            break;
        case spv::OpTypeMatrix:
            ss << ""mat"" << insn.word(3) << "" of "";
            describe_type_inner(ss, src, insn.word(2));
            break;
        case spv::OpTypeArray:
            ss << ""arr["" << get_constant_value(src, insn.word(3)) << ""] of "";
            describe_type_inner(ss, src, insn.word(2));
            break;
        case spv::OpTypePointer:
            ss << ""ptr to "" << storage_class_name(insn.word(2)) << "" "";
            describe_type_inner(ss, src, insn.word(3));
            break;
        case spv::OpTypeStruct: {
            ss << ""struct of ("";
            for (unsigned i = 2; i < insn.len(); i++) {
                describe_type_inner(ss, src, insn.word(i));
                if (i == insn.len() - 1) {
                    ss << "")"";
                } else {
                    ss << "", "";
                }
            }
            break;
        }
        case spv::OpTypeSampler:
            ss << ""sampler"";
            break;
        case spv::OpTypeSampledImage:
            ss << ""sampler+"";
            describe_type_inner(ss, src, insn.word(2));
            break;
        case spv::OpTypeImage:
            ss << ""image(dim="" << insn.word(3) << "", sampled="" << insn.word(7) << "")"";
            break;
        default:
            ss << ""oddtype"";
            break;
    }
}

static std::string describe_type(shader_module const *src, unsigned type) {
    std::ostringstream ss;
    describe_type_inner(ss, src, type);
    return ss.str();
}

static bool is_narrow_numeric_type(spirv_inst_iter type) {
    if (type.opcode() != spv::OpTypeInt && type.opcode() != spv::OpTypeFloat) return false;
    return type.word(2) < 64;
}

static bool types_match(shader_module const *a, shader_module const *b, unsigned a_type, unsigned b_type, bool a_arrayed,
                        bool b_arrayed, bool relaxed) {
    // Walk two type trees together, and complain about differences
    auto a_insn = a->get_def(a_type);
    auto b_insn = b->get_def(b_type);
    assert(a_insn != a->end());
    assert(b_insn != b->end());

    if (a_arrayed && a_insn.opcode() == spv::OpTypeArray) {
        return types_match(a, b, a_insn.word(2), b_type, false, b_arrayed, relaxed);
    }

    if (b_arrayed && b_insn.opcode() == spv::OpTypeArray) {
        // We probably just found the extra level of arrayness in b_type: compare the type inside it to a_type
        return types_match(a, b, a_type, b_insn.word(2), a_arrayed, false, relaxed);
    }

    if (a_insn.opcode() == spv::OpTypeVector && relaxed && is_narrow_numeric_type(b_insn)) {
        return types_match(a, b, a_insn.word(2), b_type, a_arrayed, b_arrayed, false);
    }

    if (a_insn.opcode() != b_insn.opcode()) {
        return false;
    }

    if (a_insn.opcode() == spv::OpTypePointer) {
        // Match on pointee type. storage class is expected to differ
        return types_match(a, b, a_insn.word(3), b_insn.word(3), a_arrayed, b_arrayed, relaxed);
    }

    if (a_arrayed || b_arrayed) {
        // If we havent resolved array-of-verts by here, we're not going to.
        return false;
    }

    switch (a_insn.opcode()) {
        case spv::OpTypeBool:
            return true;
        case spv::OpTypeInt:
            // Match on width, signedness
            return a_insn.word(2) == b_insn.word(2) && a_insn.word(3) == b_insn.word(3);
        case spv::OpTypeFloat:
            // Match on width
            return a_insn.word(2) == b_insn.word(2);
        case spv::OpTypeVector:
            // Match on element type, count.
            if (!types_match(a, b, a_insn.word(2), b_insn.word(2), a_arrayed, b_arrayed, false)) return false;
            if (relaxed && is_narrow_numeric_type(a->get_def(a_insn.word(2)))) {
                return a_insn.word(3) >= b_insn.word(3);
            } else {
                return a_insn.word(3) == b_insn.word(3);
            }
        case spv::OpTypeMatrix:
            // Match on element type, count.
            return types_match(a, b, a_insn.word(2), b_insn.word(2), a_arrayed, b_arrayed, false) &&
                a_insn.word(3) == b_insn.word(3);
        case spv::OpTypeArray:
            // Match on element type, count. these all have the same layout. we don't get here if b_arrayed. This differs from
            // vector & matrix types in that the array size is the id of a constant instruction, * not a literal within OpTypeArray
            return types_match(a, b, a_insn.word(2), b_insn.word(2), a_arrayed, b_arrayed, false) &&
                get_constant_value(a, a_insn.word(3)) == get_constant_value(b, b_insn.word(3));
        case spv::OpTypeStruct:
            // Match on all element types
        {
            if (a_insn.len() != b_insn.len()) {
                return false;  // Structs cannot match if member counts differ
            }

            for (unsigned i = 2; i < a_insn.len(); i++) {
                if (!types_match(a, b, a_insn.word(i), b_insn.word(i), a_arrayed, b_arrayed, false)) {
                    return false;
                }
            }

            return true;
        }
        default:
            // Remaining types are CLisms, or may not appear in the interfaces we are interested in. Just claim no match.
            return false;
    }
}

static unsigned value_or_default(std::unordered_map<unsigned, unsigned> const &map, unsigned id, unsigned def) {
    auto it = map.find(id);
    if (it == map.end())
        return def;
    else
        return it->second;
}

static unsigned get_locations_consumed_by_type(shader_module const *src, unsigned type, bool strip_array_level) {
    auto insn = src->get_def(type);
    assert(insn != src->end());

    switch (insn.opcode()) {
        case spv::OpTypePointer:
            // See through the ptr -- this is only ever at the toplevel for graphics shaders we're never actually passing
            // pointers around.
            return get_locations_consumed_by_type(src, insn.word(3), strip_array_level);
        case spv::OpTypeArray:
            if (strip_array_level) {
                return get_locations_consumed_by_type(src, insn.word(2), false);
            } else {
                return get_constant_value(src, insn.word(3)) * get_locations_consumed_by_type(src, insn.word(2), false);
            }
        case spv::OpTypeMatrix:
            // Num locations is the dimension * element size
            return insn.word(3) * get_locations_consumed_by_type(src, insn.word(2), false);
        case spv::OpTypeVector: {
            auto scalar_type = src->get_def(insn.word(2));
            auto bit_width =
                (scalar_type.opcode() == spv::OpTypeInt || scalar_type.opcode() == spv::OpTypeFloat) ? scalar_type.word(2) : 32;

            // Locations are 128-bit wide; 3- and 4-component vectors of 64 bit types require two.
            return (bit_width * insn.word(3) + 127) / 128;
        }
        default:
            // Everything else is just 1.
            return 1;

            // TODO: extend to handle 64bit scalar types, whose vectors may need multiple locations.
    }
}

static unsigned get_locations_consumed_by_format(VkFormat format) {
    switch (format) {
        case VK_FORMAT_R64G64B64A64_SFLOAT:
        case VK_FORMAT_R64G64B64A64_SINT:
        case VK_FORMAT_R64G64B64A64_UINT:
        case VK_FORMAT_R64G64B64_SFLOAT:
        case VK_FORMAT_R64G64B64_SINT:
        case VK_FORMAT_R64G64B64_UINT:
            return 2;
        default:
            return 1;
    }
}

static unsigned get_format_type(VkFormat fmt) {
    if (FormatIsSInt(fmt))
        return FORMAT_TYPE_SINT;
    if (FormatIsUInt(fmt))
        return FORMAT_TYPE_UINT;
    if (FormatIsDepthAndStencil(fmt))
        return FORMAT_TYPE_FLOAT | FORMAT_TYPE_UINT;
    if (fmt == VK_FORMAT_UNDEFINED)
        return 0;
    // everything else -- UNORM/SNORM/FLOAT/USCALED/SSCALED is all float in the shader.
    return FORMAT_TYPE_FLOAT;
}

// characterizes a SPIR-V type appearing in an interface to a FF stage, for comparison to a VkFormat's characterization above.
static unsigned get_fundamental_type(shader_module const *src, unsigned type) {
    auto insn = src->get_def(type);
    assert(insn != src->end());

    switch (insn.opcode()) {
        case spv::OpTypeInt:
            return insn.word(3) ? FORMAT_TYPE_SINT : FORMAT_TYPE_UINT;
        case spv::OpTypeFloat:
            return FORMAT_TYPE_FLOAT;
        case spv::OpTypeVector:
            return get_fundamental_type(src, insn.word(2));
        case spv::OpTypeMatrix:
            return get_fundamental_type(src, insn.word(2));
        case spv::OpTypeArray:
            return get_fundamental_type(src, insn.word(2));
        case spv::OpTypePointer:
            return get_fundamental_type(src, insn.word(3));
        case spv::OpTypeImage:
            return get_fundamental_type(src, insn.word(2));

        default:
            return 0;
    }
}

static uint32_t get_shader_stage_id(VkShaderStageFlagBits stage) {
    uint32_t bit_pos = uint32_t(u_ffs(stage));
    return bit_pos - 1;
}

static spirv_inst_iter get_struct_type(shader_module const *src, spirv_inst_iter def, bool is_array_of_verts) {
    while (true) {
        if (def.opcode() == spv::OpTypePointer) {
            def = src->get_def(def.word(3));
        } else if (def.opcode() == spv::OpTypeArray && is_array_of_verts) {
            def = src->get_def(def.word(2));
            is_array_of_verts = false;
        } else if (def.opcode() == spv::OpTypeStruct) {
            return def;
        } else {
            return src->end();
        }
    }
}

static bool collect_interface_block_members(shader_module const *src, std::map<location_t, interface_var> *out,
                                            std::unordered_map<unsigned, unsigned> const &blocks, bool is_array_of_verts,
                                            uint32_t id, uint32_t type_id, bool is_patch, int /*first_location*/) {
    // Walk down the type_id presented, trying to determine whether it's actually an interface block.
    auto type = get_struct_type(src, src->get_def(type_id), is_array_of_verts && !is_patch);
    if (type == src->end() || blocks.find(type.word(1)) == blocks.end()) {
        // This isn't an interface block.
        return false;
    }

    std::unordered_map<unsigned, unsigned> member_components;
    std::unordered_map<unsigned, unsigned> member_relaxed_precision;
    std::unordered_map<unsigned, unsigned> member_patch;

    // Walk all the OpMemberDecorate for type's result id -- first pass, collect components.
    for (auto insn : *src) {
        if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1)) {
            unsigned member_index = insn.word(2);

            if (insn.word(3) == spv::DecorationComponent) {
                unsigned component = insn.word(4);
                member_components[member_index] = component;
            }

            if (insn.word(3) == spv::DecorationRelaxedPrecision) {
                member_relaxed_precision[member_index] = 1;
            }

            if (insn.word(3) == spv::DecorationPatch) {
                member_patch[member_index] = 1;
            }
        }
    }

    // TODO: correctly handle location assignment from outside

    // Second pass -- produce the output, from Location decorations
    for (auto insn : *src) {
        if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1)) {
            unsigned member_index = insn.word(2);
            unsigned member_type_id = type.word(2 + member_index);

            if (insn.word(3) == spv::DecorationLocation) {
                unsigned location = insn.word(4);
                unsigned num_locations = get_locations_consumed_by_type(src, member_type_id, false);
                auto component_it = member_components.find(member_index);
                unsigned component = component_it == member_components.end() ? 0 : component_it->second;
                bool is_relaxed_precision = member_relaxed_precision.find(member_index) != member_relaxed_precision.end();
                bool member_is_patch = is_patch || member_patch.count(member_index)>0;

                for (unsigned int offset = 0; offset < num_locations; offset++) {
                    interface_var v = {};
                    v.id = id;
                    // TODO: member index in interface_var too?
                    v.type_id = member_type_id;
                    v.offset = offset;
                    v.is_patch = member_is_patch;
                    v.is_block_member = true;
                    v.is_relaxed_precision = is_relaxed_precision;
                    (*out)[std::make_pair(location + offset, component)] = v;
                }
            }
        }
    }

    return true;
}

static std::map<location_t, interface_var> collect_interface_by_location(shader_module const *src, spirv_inst_iter entrypoint,
                                                                         spv::StorageClass sinterface, bool is_array_of_verts) {
    std::unordered_map<unsigned, unsigned> var_locations;
    std::unordered_map<unsigned, unsigned> var_builtins;
    std::unordered_map<unsigned, unsigned> var_components;
    std::unordered_map<unsigned, unsigned> blocks;
    std::unordered_map<unsigned, unsigned> var_patch;
    std::unordered_map<unsigned, unsigned> var_relaxed_precision;

    for (auto insn : *src) {
        // We consider two interface models: SSO rendezvous-by-location, and builtins. Complain about anything that
        // fits neither model.
        if (insn.opcode() == spv::OpDecorate) {
            if (insn.word(2) == spv::DecorationLocation) {
                var_locations[insn.word(1)] = insn.word(3);
            }

            if (insn.word(2) == spv::DecorationBuiltIn) {
                var_builtins[insn.word(1)] = insn.word(3);
            }

            if (insn.word(2) == spv::DecorationComponent) {
                var_components[insn.word(1)] = insn.word(3);
            }

            if (insn.word(2) == spv::DecorationBlock) {
                blocks[insn.word(1)] = 1;
            }

            if (insn.word(2) == spv::DecorationPatch) {
                var_patch[insn.word(1)] = 1;
            }

            if (insn.word(2) == spv::DecorationRelaxedPrecision) {
                var_relaxed_precision[insn.word(1)] = 1;
            }
        }
    }

    // TODO: handle grouped decorations
    // TODO: handle index=1 dual source outputs from FS -- two vars will have the same location, and we DON'T want to clobber.

    // Find the end of the entrypoint's name string. additional zero bytes follow the actual null terminator, to fill out the
    // rest of the word - so we only need to look at the last byte in the word to determine which word contains the terminator.
    uint32_t word = 3;
    while (entrypoint.word(word) & 0xff000000u) {
        ++word;
    }
    ++word;

    std::map<location_t, interface_var> out;

    for (; word < entrypoint.len(); word++) {
        auto insn = src->get_def(entrypoint.word(word));
        assert(insn != src->end());
        assert(insn.opcode() == spv::OpVariable);

        if (insn.word(3) == static_cast<uint32_t>(sinterface)) {
            unsigned id = insn.word(2);
            unsigned type = insn.word(1);

            int location = value_or_default(var_locations, id, -1);
            int builtin = value_or_default(var_builtins, id, -1);
            unsigned component = value_or_default(var_components, id, 0);  // Unspecified is OK, is 0
            bool is_patch = var_patch.find(id) != var_patch.end();
            bool is_relaxed_precision = var_relaxed_precision.find(id) != var_relaxed_precision.end();

            if (builtin != -1) continue;
            else if (!collect_interface_block_members(src, &out, blocks, is_array_of_verts, id, type, is_patch, location)) {
                // A user-defined interface variable, with a location. Where a variable occupied multiple locations, emit
                // one result for each.
                unsigned num_locations = get_locations_consumed_by_type(src, type, is_array_of_verts && !is_patch);
                for (unsigned int offset = 0; offset < num_locations; offset++) {
                    interface_var v = {};
                    v.id = id;
                    v.type_id = type;
                    v.offset = offset;
                    v.is_patch = is_patch;
                    v.is_relaxed_precision = is_relaxed_precision;
                    out[std::make_pair(location + offset, component)] = v;
                }
            }
        }
    }

    return out;
}

static std::vector<std::pair<uint32_t, interface_var>> collect_interface_by_input_attachment_index(
    shader_module const *src, std::unordered_set<uint32_t> const &accessible_ids) {
    std::vector<std::pair<uint32_t, interface_var>> out;

    for (auto insn : *src) {
        if (insn.opcode() == spv::OpDecorate) {
            if (insn.word(2) == spv::DecorationInputAttachmentIndex) {
                auto attachment_index = insn.word(3);
                auto id = insn.word(1);

                if (accessible_ids.count(id)) {
                    auto def = src->get_def(id);
                    assert(def != src->end());

                    if (def.opcode() == spv::OpVariable && insn.word(3) == spv::StorageClassUniformConstant) {
                        auto num_locations = get_locations_consumed_by_type(src, def.word(1), false);
                        for (unsigned int offset = 0; offset < num_locations; offset++) {
                            interface_var v = {};
                            v.id = id;
                            v.type_id = def.word(1);
                            v.offset = offset;
                            out.emplace_back(attachment_index + offset, v);
                        }
                    }
                }
            }
        }
    }

    return out;
}

static std::vector<std::pair<descriptor_slot_t, interface_var>> collect_interface_by_descriptor_slot(
    debug_report_data const *report_data, shader_module const *src, std::unordered_set<uint32_t> const &accessible_ids) {
    std::unordered_map<unsigned, unsigned> var_sets;
    std::unordered_map<unsigned, unsigned> var_bindings;

    for (auto insn : *src) {
        // All variables in the Uniform or UniformConstant storage classes are required to be decorated with both
        // DecorationDescriptorSet and DecorationBinding.
        if (insn.opcode() == spv::OpDecorate) {
            if (insn.word(2) == spv::DecorationDescriptorSet) {
                var_sets[insn.word(1)] = insn.word(3);
            }

            if (insn.word(2) == spv::DecorationBinding) {
                var_bindings[insn.word(1)] = insn.word(3);
            }
        }
    }

    std::vector<std::pair<descriptor_slot_t, interface_var>> out;

    for (auto id : accessible_ids) {
        auto insn = src->get_def(id);
        assert(insn != src->end());

        if (insn.opcode() == spv::OpVariable &&
            (insn.word(3) == spv::StorageClassUniform || insn.word(3) == spv::StorageClassUniformConstant)) {
            unsigned set = value_or_default(var_sets, insn.word(2), 0);
            unsigned binding = value_or_default(var_bindings, insn.word(2), 0);

            interface_var v = {};
            v.id = insn.word(2);
            v.type_id = insn.word(1);
            out.emplace_back(std::make_pair(set, binding), v);
        }
    }

    return out;
}



static bool validate_vi_consistency(debug_report_data const *report_data, VkPipelineVertexInputStateCreateInfo const *vi) {
    // Walk the binding descriptions, which describe the step rate and stride of each vertex buffer.  Each binding should
    // be specified only once.
    std::unordered_map<uint32_t, VkVertexInputBindingDescription const *> bindings;
    bool skip = false;

    for (unsigned i = 0; i < vi->vertexBindingDescriptionCount; i++) {
        auto desc = &vi->pVertexBindingDescriptions[i];
        auto &binding = bindings[desc->binding];
        if (binding) {
            // TODO: VALIDATION_ERROR_096005cc perhaps?
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_INCONSISTENT_VI, ""SC"", ""Duplicate vertex input binding descriptions for binding %d"",
                            desc->binding);
        } else {
            binding = desc;
        }
    }

    return skip;
}

static bool validate_vi_against_vs_inputs(debug_report_data const *report_data, VkPipelineVertexInputStateCreateInfo const *vi,
                                          shader_module const *vs, spirv_inst_iter entrypoint) {
    bool skip = false;

    auto inputs = collect_interface_by_location(vs, entrypoint, spv::StorageClassInput, false);

    // Build index by location
    std::map<uint32_t, VkVertexInputAttributeDescription const *> attribs;
    if (vi) {
        for (unsigned i = 0; i < vi->vertexAttributeDescriptionCount; i++) {
            auto num_locations = get_locations_consumed_by_format(vi->pVertexAttributeDescriptions[i].format);
            for (auto j = 0u; j < num_locations; j++) {
                attribs[vi->pVertexAttributeDescriptions[i].location + j] = &vi->pVertexAttributeDescriptions[i];
            }
        }
    }

    auto it_a = attribs.begin();
    auto it_b = inputs.begin();
    bool used = false;

    while ((attribs.size() > 0 && it_a != attribs.end()) || (inputs.size() > 0 && it_b != inputs.end())) {
        bool a_at_end = attribs.size() == 0 || it_a == attribs.end();
        bool b_at_end = inputs.size() == 0 || it_b == inputs.end();
        auto a_first = a_at_end ? 0 : it_a->first;
        auto b_first = b_at_end ? 0 : it_b->first.first;
        if (!a_at_end && (b_at_end || a_first < b_first)) {
            if (!used && log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
                                 0, __LINE__, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, ""SC"",
                                 ""Vertex attribute at location %d not consumed by vertex shader"", a_first)) {
                skip = true;
            }
            used = false;
            it_a++;
        } else if (!b_at_end && (a_at_end || b_first < a_first)) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
                            SHADER_CHECKER_INPUT_NOT_PRODUCED, ""SC"", ""Vertex shader consumes input at location %d but not provided"",
                            b_first);
            it_b++;
        } else {
            unsigned attrib_type = get_format_type(it_a->second->format);
            unsigned input_type = get_fundamental_type(vs, it_b->second.type_id);

            // Type checking
            if (!(attrib_type & input_type)) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                                SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, ""SC"",
                                ""Attribute type of `%s` at location %d does not match vertex shader input type of `%s`"",
                                string_VkFormat(it_a->second->format), a_first, describe_type(vs, it_b->second.type_id).c_str());
            }

            // OK!
            used = true;
            it_b++;
        }
    }

    return skip;
}

static bool validate_fs_outputs_against_render_pass(debug_report_data const *report_data, shader_module const *fs,
                                                    spirv_inst_iter entrypoint, PIPELINE_STATE const *pipeline,
                                                    uint32_t subpass_index) {
    auto rpci = pipeline->render_pass_ci.ptr();

    std::map<uint32_t, VkFormat> color_attachments;
    auto subpass = rpci->pSubpasses[subpass_index];
    for (auto i = 0u; i < subpass.colorAttachmentCount; ++i) {
        uint32_t attachment = subpass.pColorAttachments[i].attachment;
        if (attachment == VK_ATTACHMENT_UNUSED) continue;
        if (rpci->pAttachments[attachment].format != VK_FORMAT_UNDEFINED) {
            color_attachments[i] = rpci->pAttachments[attachment].format;
        }
    }

    bool skip = false;

    // TODO: dual source blend index (spv::DecIndex, zero if not provided)

    auto outputs = collect_interface_by_location(fs, entrypoint, spv::StorageClassOutput, false);

    auto it_a = outputs.begin();
    auto it_b = color_attachments.begin();

    // Walk attachment list and outputs together

    while ((outputs.size() > 0 && it_a != outputs.end()) || (color_attachments.size() > 0 && it_b != color_attachments.end())) {
        bool a_at_end = outputs.size() == 0 || it_a == outputs.end();
        bool b_at_end = color_attachments.size() == 0 || it_b == color_attachments.end();

        if (!a_at_end && (b_at_end || it_a->first.first < it_b->first)) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_OUTPUT_NOT_CONSUMED, ""SC"",
                            ""fragment shader writes to output location %d with no matching attachment"", it_a->first.first);
            it_a++;
        } else if (!b_at_end && (a_at_end || it_a->first.first > it_b->first)) {
            // Only complain if there are unmasked channels for this attachment. If the writemask is 0, it's acceptable for the
            // shader to not produce a matching output.
            if (pipeline->attachments[it_b->first].colorWriteMask != 0) {
                skip |=
                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_INPUT_NOT_PRODUCED, ""SC"", ""Attachment %d not written by fragment shader"", it_b->first);
            }
            it_b++;
        } else {
            unsigned output_type = get_fundamental_type(fs, it_a->second.type_id);
            unsigned att_type = get_format_type(it_b->second);

            // Type checking
            if (!(output_type & att_type)) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                                SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, ""SC"",
                                ""Attachment %d of type `%s` does not match fragment shader output type of `%s`"", it_b->first,
                                string_VkFormat(it_b->second), describe_type(fs, it_a->second.type_id).c_str());
            }

            // OK!
            it_a++;
            it_b++;
        }
    }

    return skip;
}

// For some analyses, we need to know about all ids referenced by the static call tree of a particular entrypoint. This is
// important for identifying the set of shader resources actually used by an entrypoint, for example.
// Note: we only explore parts of the image which might actually contain ids we care about for the above analyses.
//  - NOT the shader input/output interfaces.
//
// TODO: The set of interesting opcodes here was determined by eyeballing the SPIRV spec. It might be worth
// converting parts of this to be generated from the machine-readable spec instead.
static std::unordered_set<uint32_t> mark_accessible_ids(shader_module const *src, spirv_inst_iter entrypoint) {
    std::unordered_set<uint32_t> ids;
    std::unordered_set<uint32_t> worklist;
    worklist.insert(entrypoint.word(2));

    while (!worklist.empty()) {
        auto id_iter = worklist.begin();
        auto id = *id_iter;
        worklist.erase(id_iter);

        auto insn = src->get_def(id);
        if (insn == src->end()) {
            // ID is something we didn't collect in build_def_index. that's OK -- we'll stumble across all kinds of things here
            // that we may not care about.
            continue;
        }

        // Try to add to the output set
        if (!ids.insert(id).second) {
            continue;  // If we already saw this id, we don't want to walk it again.
        }

        switch (insn.opcode()) {
            case spv::OpFunction:
                // Scan whole body of the function, enlisting anything interesting
                while (++insn, insn.opcode() != spv::OpFunctionEnd) {
                    switch (insn.opcode()) {
                        case spv::OpLoad:
                        case spv::OpAtomicLoad:
                        case spv::OpAtomicExchange:
                        case spv::OpAtomicCompareExchange:
                        case spv::OpAtomicCompareExchangeWeak:
                        case spv::OpAtomicIIncrement:
                        case spv::OpAtomicIDecrement:
                        case spv::OpAtomicIAdd:
                        case spv::OpAtomicISub:
                        case spv::OpAtomicSMin:
                        case spv::OpAtomicUMin:
                        case spv::OpAtomicSMax:
                        case spv::OpAtomicUMax:
                        case spv::OpAtomicAnd:
                        case spv::OpAtomicOr:
                        case spv::OpAtomicXor:
                            worklist.insert(insn.word(3));  // ptr
                            break;
                        case spv::OpStore:
                        case spv::OpAtomicStore:
                            worklist.insert(insn.word(1));  // ptr
                            break;
                        case spv::OpAccessChain:
                        case spv::OpInBoundsAccessChain:
                            worklist.insert(insn.word(3));  // base ptr
                            break;
                        case spv::OpSampledImage:
                        case spv::OpImageSampleImplicitLod:
                        case spv::OpImageSampleExplicitLod:
                        case spv::OpImageSampleDrefImplicitLod:
                        case spv::OpImageSampleDrefExplicitLod:
                        case spv::OpImageSampleProjImplicitLod:
                        case spv::OpImageSampleProjExplicitLod:
                        case spv::OpImageSampleProjDrefImplicitLod:
                        case spv::OpImageSampleProjDrefExplicitLod:
                        case spv::OpImageFetch:
                        case spv::OpImageGather:
                        case spv::OpImageDrefGather:
                        case spv::OpImageRead:
                        case spv::OpImage:
                        case spv::OpImageQueryFormat:
                        case spv::OpImageQueryOrder:
                        case spv::OpImageQuerySizeLod:
                        case spv::OpImageQuerySize:
                        case spv::OpImageQueryLod:
                        case spv::OpImageQueryLevels:
                        case spv::OpImageQuerySamples:
                        case spv::OpImageSparseSampleImplicitLod:
                        case spv::OpImageSparseSampleExplicitLod:
                        case spv::OpImageSparseSampleDrefImplicitLod:
                        case spv::OpImageSparseSampleDrefExplicitLod:
                        case spv::OpImageSparseSampleProjImplicitLod:
                        case spv::OpImageSparseSampleProjExplicitLod:
                        case spv::OpImageSparseSampleProjDrefImplicitLod:
                        case spv::OpImageSparseSampleProjDrefExplicitLod:
                        case spv::OpImageSparseFetch:
                        case spv::OpImageSparseGather:
                        case spv::OpImageSparseDrefGather:
                        case spv::OpImageTexelPointer:
                            worklist.insert(insn.word(3));  // Image or sampled image
                            break;
                        case spv::OpImageWrite:
                            worklist.insert(insn.word(1));  // Image -- different operand order to above
                            break;
                        case spv::OpFunctionCall:
                            for (uint32_t i = 3; i < insn.len(); i++) {
                                worklist.insert(insn.word(i));  // fn itself, and all args
                            }
                            break;

                        case spv::OpExtInst:
                            for (uint32_t i = 5; i < insn.len(); i++) {
                                worklist.insert(insn.word(i));  // Operands to ext inst
                            }
                            break;
                    }
                }
                break;
        }
    }

    return ids;
}

static bool validate_push_constant_block_against_pipeline(debug_report_data const *report_data,
                                                          std::vector<VkPushConstantRange> const *push_constant_ranges,
                                                          shader_module const *src, spirv_inst_iter type,
                                                          VkShaderStageFlagBits stage) {
    bool skip = false;

    // Strip off ptrs etc
    type = get_struct_type(src, type, false);
    assert(type != src->end());

    // Validate directly off the offsets. this isn't quite correct for arrays and matrices, but is a good first step.
    // TODO: arrays, matrices, weird sizes
    for (auto insn : *src) {
        if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1)) {
            if (insn.word(3) == spv::DecorationOffset) {
                unsigned offset = insn.word(4);
                auto size = 4;  // Bytes; TODO: calculate this based on the type

                bool found_range = false;
                for (auto const &range : *push_constant_ranges) {
                    if (range.offset <= offset && range.offset + range.size >= offset + size) {
                        found_range = true;

                        if ((range.stageFlags & stage) == 0) {
                            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                                            __LINE__, SHADER_CHECKER_PUSH_CONSTANT_NOT_ACCESSIBLE_FROM_STAGE, ""SC"",
                                            ""Push constant range covering variable starting at ""
                                                ""offset %u not accessible from stage %s"",
                                            offset, string_VkShaderStageFlagBits(stage));
                        }

                        break;
                    }
                }

                if (!found_range) {
                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                                    __LINE__, SHADER_CHECKER_PUSH_CONSTANT_OUT_OF_RANGE, ""SC"",
                                    ""Push constant range covering variable starting at ""
                                        ""offset %u not declared in layout"",
                                    offset);
                }
            }
        }
    }

    return skip;
}

static bool validate_push_constant_usage(debug_report_data const *report_data,
                                         std::vector<VkPushConstantRange> const *push_constant_ranges, shader_module const *src,
                                         std::unordered_set<uint32_t> accessible_ids, VkShaderStageFlagBits stage) {
    bool skip = false;

    for (auto id : accessible_ids) {
        auto def_insn = src->get_def(id);
        if (def_insn.opcode() == spv::OpVariable && def_insn.word(3) == spv::StorageClassPushConstant) {
            skip |= validate_push_constant_block_against_pipeline(report_data, push_constant_ranges, src,
                                                                  src->get_def(def_insn.word(1)), stage);
        }
    }

    return skip;
}

// Validate that data for each specialization entry is fully contained within the buffer.
static bool validate_specialization_offsets(debug_report_data const *report_data, VkPipelineShaderStageCreateInfo const *info) {
    bool skip = false;

    VkSpecializationInfo const *spec = info->pSpecializationInfo;

    if (spec) {
        for (auto i = 0u; i < spec->mapEntryCount; i++) {
            // TODO: This is a good place for VALIDATION_ERROR_1360060a.
            if (spec->pMapEntries[i].offset + spec->pMapEntries[i].size > spec->dataSize) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
                                VALIDATION_ERROR_1360060c, ""SC"",
                                ""Specialization entry %u (for constant id %u) references memory outside provided ""
                                    ""specialization data (bytes %u.."" PRINTF_SIZE_T_SPECIFIER ""; "" PRINTF_SIZE_T_SPECIFIER
                "" bytes provided). %s."",
                    i, spec->pMapEntries[i].constantID, spec->pMapEntries[i].offset,
                    spec->pMapEntries[i].offset + spec->pMapEntries[i].size - 1, spec->dataSize,
                    validation_error_map[VALIDATION_ERROR_1360060c]);
            }
        }
    }

    return skip;
}

static bool descriptor_type_match(shader_module const *module, uint32_t type_id, VkDescriptorType descriptor_type,
                                  unsigned &descriptor_count) {
    auto type = module->get_def(type_id);

    descriptor_count = 1;

    // Strip off any array or ptrs. Where we remove array levels, adjust the  descriptor count for each dimension.
    while (type.opcode() == spv::OpTypeArray || type.opcode() == spv::OpTypePointer) {
        if (type.opcode() == spv::OpTypeArray) {
            descriptor_count *= get_constant_value(module, type.word(3));
            type = module->get_def(type.word(2));
        } else {
            type = module->get_def(type.word(3));
        }
    }

    switch (type.opcode()) {
        case spv::OpTypeStruct: {
            for (auto insn : *module) {
                if (insn.opcode() == spv::OpDecorate && insn.word(1) == type.word(1)) {
                    if (insn.word(2) == spv::DecorationBlock) {
                        return descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER ||
                            descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
                    } else if (insn.word(2) == spv::DecorationBufferBlock) {
                        return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER ||
                            descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
                    }
                }
            }

            // Invalid
            return false;
        }

        case spv::OpTypeSampler:
            return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLER || descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;

        case spv::OpTypeSampledImage:
            if (descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) {
                // Slight relaxation for some GLSL historical madness: samplerBuffer doesn't really have a sampler, and a texel
                // buffer descriptor doesn't really provide one. Allow this slight mismatch.
                auto image_type = module->get_def(type.word(2));
                auto dim = image_type.word(3);
                auto sampled = image_type.word(7);
                return dim == spv::DimBuffer && sampled == 1;
            }
            return descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;

        case spv::OpTypeImage: {
            // Many descriptor types backing image types-- depends on dimension and whether the image will be used with a sampler.
            // SPIRV for Vulkan requires that sampled be 1 or 2 -- leaving the decision to runtime is unacceptable.
            auto dim = type.word(3);
            auto sampled = type.word(7);

            if (dim == spv::DimSubpassData) {
                return descriptor_type == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
            } else if (dim == spv::DimBuffer) {
                if (sampled == 1) {
                    return descriptor_type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
                } else {
                    return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
                }
            } else if (sampled == 1) {
                return descriptor_type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE ||
                    descriptor_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
            } else {
                return descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
            }
        }

            // We shouldn't really see any other junk types -- but if we do, they're a mismatch.
        default:
            return false;  // Mismatch
    }
}

static bool require_feature(debug_report_data const *report_data, VkBool32 feature, char const *feature_name) {
    if (!feature) {
        if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                    SHADER_CHECKER_FEATURE_NOT_ENABLED, ""SC"",
                    ""Shader requires VkPhysicalDeviceFeatures::%s but is not ""
                        ""enabled on the device"",
                    feature_name)) {
            return true;
        }
    }

    return false;
}

static bool require_extension(debug_report_data const *report_data, bool extension, char const *extension_name) {
    if (!extension) {
        if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                    SHADER_CHECKER_FEATURE_NOT_ENABLED, ""SC"",
                    ""Shader requires extension %s but is not ""
                        ""enabled on the device"",
                    extension_name)) {
            return true;
        }
    }

    return false;
}

static bool validate_shader_capabilities(layer_data *dev_data, shader_module const *src) {
    bool skip = false;

    auto report_data = GetReportData(dev_data);
    auto const & enabledFeatures = GetEnabledFeatures(dev_data);
    auto const & extensions = GetEnabledExtensions(dev_data);

    struct CapabilityInfo {
        char const *name;
        VkBool32 const VkPhysicalDeviceFeatures::*feature;
        bool const DeviceExtensions::*extension;
    };

    using F = VkPhysicalDeviceFeatures;
    using E = DeviceExtensions;

    // clang-format off
    static const std::unordered_map<uint32_t, CapabilityInfo> capabilities = {
        // Capabilities always supported by a Vulkan 1.0 implementation -- no
        // feature bits.
        {spv::CapabilityMatrix, {nullptr}},
        {spv::CapabilityShader, {nullptr}},
        {spv::CapabilityInputAttachment, {nullptr}},
        {spv::CapabilitySampled1D, {nullptr}},
        {spv::CapabilityImage1D, {nullptr}},
        {spv::CapabilitySampledBuffer, {nullptr}},
        {spv::CapabilityImageQuery, {nullptr}},
        {spv::CapabilityDerivativeControl, {nullptr}},

        // Capabilities that are optionally supported, but require a feature to
        // be enabled on the device
        {spv::CapabilityGeometry, {""geometryShader"", &F::geometryShader}},
        {spv::CapabilityTessellation, {""tessellationShader"", &F::tessellationShader}},
        {spv::CapabilityFloat64, {""shaderFloat64"", &F::shaderFloat64}},
        {spv::CapabilityInt64, {""shaderInt64"", &F::shaderInt64}},
        {spv::CapabilityTessellationPointSize, {""shaderTessellationAndGeometryPointSize"", &F::shaderTessellationAndGeometryPointSize}},
        {spv::CapabilityGeometryPointSize, {""shaderTessellationAndGeometryPointSize"", &F::shaderTessellationAndGeometryPointSize}},
        {spv::CapabilityImageGatherExtended, {""shaderImageGatherExtended"", &F::shaderImageGatherExtended}},
        {spv::CapabilityStorageImageMultisample, {""shaderStorageImageMultisample"", &F::shaderStorageImageMultisample}},
        {spv::CapabilityUniformBufferArrayDynamicIndexing, {""shaderUniformBufferArrayDynamicIndexing"", &F::shaderUniformBufferArrayDynamicIndexing}},
        {spv::CapabilitySampledImageArrayDynamicIndexing, {""shaderSampledImageArrayDynamicIndexing"", &F::shaderSampledImageArrayDynamicIndexing}},
        {spv::CapabilityStorageBufferArrayDynamicIndexing, {""shaderStorageBufferArrayDynamicIndexing"", &F::shaderStorageBufferArrayDynamicIndexing}},
        {spv::CapabilityStorageImageArrayDynamicIndexing, {""shaderStorageImageArrayDynamicIndexing"", &F::shaderStorageBufferArrayDynamicIndexing}},
        {spv::CapabilityClipDistance, {""shaderClipDistance"", &F::shaderClipDistance}},
        {spv::CapabilityCullDistance, {""shaderCullDistance"", &F::shaderCullDistance}},
        {spv::CapabilityImageCubeArray, {""imageCubeArray"", &F::imageCubeArray}},
        {spv::CapabilitySampleRateShading, {""sampleRateShading"", &F::sampleRateShading}},
        {spv::CapabilitySparseResidency, {""shaderResourceResidency"", &F::shaderResourceResidency}},
        {spv::CapabilityMinLod, {""shaderResourceMinLod"", &F::shaderResourceMinLod}},
        {spv::CapabilitySampledCubeArray, {""imageCubeArray"", &F::imageCubeArray}},
        {spv::CapabilityImageMSArray, {""shaderStorageImageMultisample"", &F::shaderStorageImageMultisample}},
        {spv::CapabilityStorageImageExtendedFormats, {""shaderStorageImageExtendedFormats"", &F::shaderStorageImageExtendedFormats}},
        {spv::CapabilityInterpolationFunction, {""sampleRateShading"", &F::sampleRateShading}},
        {spv::CapabilityStorageImageReadWithoutFormat, {""shaderStorageImageReadWithoutFormat"", &F::shaderStorageImageReadWithoutFormat}},
        {spv::CapabilityStorageImageWriteWithoutFormat, {""shaderStorageImageWriteWithoutFormat"", &F::shaderStorageImageWriteWithoutFormat}},
        {spv::CapabilityMultiViewport, {""multiViewport"", &F::multiViewport}},

        // Capabilities that require an extension
        {spv::CapabilityDrawParameters, {VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, nullptr, &E::vk_khr_shader_draw_parameters}},
        {spv::CapabilityGeometryShaderPassthroughNV, {VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME, nullptr, &E::vk_nv_geometry_shader_passthrough}},
        {spv::CapabilitySampleMaskOverrideCoverageNV, {VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME, nullptr, &E::vk_nv_sample_mask_override_coverage}},
        {spv::CapabilityShaderViewportIndexLayerNV, {VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, nullptr, &E::vk_nv_viewport_array2}},
        {spv::CapabilityShaderViewportMaskNV, {VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, nullptr, &E::vk_nv_viewport_array2}},
        {spv::CapabilitySubgroupBallotKHR, {VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, nullptr, &E::vk_ext_shader_subgroup_ballot }},
        {spv::CapabilitySubgroupVoteKHR, {VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, nullptr, &E::vk_ext_shader_subgroup_vote }},
    };
    // clang-format on

    for (auto insn : *src) {
        if (insn.opcode() == spv::OpCapability) {
            auto it = capabilities.find(insn.word(1));
            if (it != capabilities.end()) {
                if (it->second.feature) {
                    skip |= require_feature(report_data, enabledFeatures->*(it->second.feature), it->second.name);
                }
                if (it->second.extension) {
                    skip |= require_extension(report_data, extensions->*(it->second.extension), it->second.name);
                }
            }
        }
    }

    return skip;
}

static uint32_t descriptor_type_to_reqs(shader_module const *module, uint32_t type_id) {
    auto type = module->get_def(type_id);

    while (true) {
        switch (type.opcode()) {
            case spv::OpTypeArray:
            case spv::OpTypeSampledImage:
                type = module->get_def(type.word(2));
                break;
            case spv::OpTypePointer:
                type = module->get_def(type.word(3));
                break;
            case spv::OpTypeImage: {
                auto dim = type.word(3);
                auto arrayed = type.word(5);
                auto msaa = type.word(6);

                switch (dim) {
                    case spv::Dim1D:
                        return arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_1D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_1D;
                    case spv::Dim2D:
                        return (msaa ? DESCRIPTOR_REQ_MULTI_SAMPLE : DESCRIPTOR_REQ_SINGLE_SAMPLE) |
                            (arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_2D_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_2D);
                    case spv::Dim3D:
                        return DESCRIPTOR_REQ_VIEW_TYPE_3D;
                    case spv::DimCube:
                        return arrayed ? DESCRIPTOR_REQ_VIEW_TYPE_CUBE_ARRAY : DESCRIPTOR_REQ_VIEW_TYPE_CUBE;
                    case spv::DimSubpassData:
                        return msaa ? DESCRIPTOR_REQ_MULTI_SAMPLE : DESCRIPTOR_REQ_SINGLE_SAMPLE;
                    default:  // buffer, etc.
                        return 0;
                }
            }
            default:
                return 0;
        }
    }
}

// For given pipelineLayout verify that the set_layout_node at slot.first
//  has the requested binding at slot.second and return ptr to that binding
static VkDescriptorSetLayoutBinding const *get_descriptor_binding(PIPELINE_LAYOUT_NODE const *pipelineLayout,
                                                                  descriptor_slot_t slot) {
    if (!pipelineLayout) return nullptr;

    if (slot.first >= pipelineLayout->set_layouts.size()) return nullptr;

    return pipelineLayout->set_layouts[slot.first]->GetDescriptorSetLayoutBindingPtrFromBinding(slot.second);
}


static bool validate_pipeline_shader_stage(
    layer_data *dev_data, VkPipelineShaderStageCreateInfo const *pStage, PIPELINE_STATE *pipeline,
    shader_module const **out_module, spirv_inst_iter *out_entrypoint) {
    bool skip = false;
    auto module = *out_module = GetShaderModuleState(dev_data, pStage->module);
    auto report_data = GetReportData(dev_data);

    if (!module->has_valid_spirv) return false;

    // Find the entrypoint
    auto entrypoint = *out_entrypoint = find_entrypoint(module, pStage->pName, pStage->stage);
    if (entrypoint == module->end()) {
        if (log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                    VALIDATION_ERROR_10600586, ""SC"", ""No entrypoint found named `%s` for stage %s. %s."", pStage->pName,
                    string_VkShaderStageFlagBits(pStage->stage), validation_error_map[VALIDATION_ERROR_10600586])) {
            return true;  // no point continuing beyond here, any analysis is just going to be garbage.
        }
    }

    // Validate shader capabilities against enabled device features
    skip |= validate_shader_capabilities(dev_data, module);

    // Mark accessible ids
    auto accessible_ids = mark_accessible_ids(module, entrypoint);

    // Validate descriptor set layout against what the entrypoint actually uses
    auto descriptor_uses = collect_interface_by_descriptor_slot(report_data, module, accessible_ids);

    skip |= validate_specialization_offsets(report_data, pStage);
    skip |= validate_push_constant_usage(report_data, &pipeline->pipeline_layout.push_constant_ranges, module, accessible_ids, pStage->stage);

    // Validate descriptor use
    for (auto use : descriptor_uses) {
        // While validating shaders capture which slots are used by the pipeline
        auto &reqs = pipeline->active_slots[use.first.first][use.first.second];
        reqs = descriptor_req(reqs | descriptor_type_to_reqs(module, use.second.type_id));

        // Verify given pipelineLayout has requested setLayout with requested binding
        const auto &binding = get_descriptor_binding(&pipeline->pipeline_layout, use.first);
        unsigned required_descriptor_count;

        if (!binding) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_MISSING_DESCRIPTOR, ""SC"",
                            ""Shader uses descriptor slot %u.%u (used as type `%s`) but not declared in pipeline layout"",
                            use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str());
        } else if (~binding->stageFlags & pStage->stage) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
                            SHADER_CHECKER_DESCRIPTOR_NOT_ACCESSIBLE_FROM_STAGE, ""SC"",
                            ""Shader uses descriptor slot %u.%u (used ""
                                ""as type `%s`) but descriptor not ""
                                ""accessible from stage %s"",
                            use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str(),
                            string_VkShaderStageFlagBits(pStage->stage));
        } else if (!descriptor_type_match(module, use.second.type_id, binding->descriptorType, required_descriptor_count)) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_DESCRIPTOR_TYPE_MISMATCH, ""SC"",
                            ""Type mismatch on descriptor slot ""
                                ""%u.%u (used as type `%s`) but ""
                                ""descriptor of type %s"",
                            use.first.first, use.first.second, describe_type(module, use.second.type_id).c_str(),
                            string_VkDescriptorType(binding->descriptorType));
        } else if (binding->descriptorCount < required_descriptor_count) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_DESCRIPTOR_TYPE_MISMATCH, ""SC"",
                            ""Shader expects at least %u descriptors for binding %u.%u (used as type `%s`) but only %u provided"",
                            required_descriptor_count, use.first.first, use.first.second,
                            describe_type(module, use.second.type_id).c_str(), binding->descriptorCount);
        }
    }

    // Validate use of input attachments against subpass structure
    if (pStage->stage == VK_SHADER_STAGE_FRAGMENT_BIT) {
        auto input_attachment_uses = collect_interface_by_input_attachment_index(module, accessible_ids);

        auto rpci = pipeline->render_pass_ci.ptr();
        auto subpass = pipeline->graphicsPipelineCI.subpass;

        for (auto use : input_attachment_uses) {
            auto input_attachments = rpci->pSubpasses[subpass].pInputAttachments;
            auto index = (input_attachments && use.first < rpci->pSubpasses[subpass].inputAttachmentCount)
                         ? input_attachments[use.first].attachment
                         : VK_ATTACHMENT_UNUSED;

            if (index == VK_ATTACHMENT_UNUSED) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                                SHADER_CHECKER_MISSING_INPUT_ATTACHMENT, ""SC"",
                                ""Shader consumes input attachment index %d but not provided in subpass"", use.first);
            } else if (!(get_format_type(rpci->pAttachments[index].format) & get_fundamental_type(module, use.second.type_id))) {
                skip |=
                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_INPUT_ATTACHMENT_TYPE_MISMATCH, ""SC"",
                            ""Subpass input attachment %u format of %s does not match type used in shader `%s`"", use.first,
                            string_VkFormat(rpci->pAttachments[index].format), describe_type(module, use.second.type_id).c_str());
            }
        }
    }

    return skip;
}

static bool validate_interface_between_stages(debug_report_data const *report_data, shader_module const *producer,
                                              spirv_inst_iter producer_entrypoint, shader_stage_attributes const *producer_stage,
                                              shader_module const *consumer, spirv_inst_iter consumer_entrypoint,
                                              shader_stage_attributes const *consumer_stage) {
    bool skip = false;

    auto outputs =
        collect_interface_by_location(producer, producer_entrypoint, spv::StorageClassOutput, producer_stage->arrayed_output);
    auto inputs =
        collect_interface_by_location(consumer, consumer_entrypoint, spv::StorageClassInput, consumer_stage->arrayed_input);

    auto a_it = outputs.begin();
    auto b_it = inputs.begin();

    // Maps sorted by key (location); walk them together to find mismatches
    while ((outputs.size() > 0 && a_it != outputs.end()) || (inputs.size() && b_it != inputs.end())) {
        bool a_at_end = outputs.size() == 0 || a_it == outputs.end();
        bool b_at_end = inputs.size() == 0 || b_it == inputs.end();
        auto a_first = a_at_end ? std::make_pair(0u, 0u) : a_it->first;
        auto b_first = b_at_end ? std::make_pair(0u, 0u) : b_it->first;

        if (b_at_end || ((!a_at_end) && (a_first < b_first))) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                            __LINE__, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, ""SC"",
                            ""%s writes to output location %u.%u which is not consumed by %s"", producer_stage->name, a_first.first,
                            a_first.second, consumer_stage->name);
            a_it++;
        } else if (a_at_end || a_first > b_first) {
            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                            SHADER_CHECKER_INPUT_NOT_PRODUCED, ""SC"", ""%s consumes input location %u.%u which is not written by %s"",
                            consumer_stage->name, b_first.first, b_first.second, producer_stage->name);
            b_it++;
        } else {
            // subtleties of arrayed interfaces:
            // - if is_patch, then the member is not arrayed, even though the interface may be.
            // - if is_block_member, then the extra array level of an arrayed interface is not
            //   expressed in the member type -- it's expressed in the block type.
            if (!types_match(producer, consumer, a_it->second.type_id, b_it->second.type_id,
                             producer_stage->arrayed_output && !a_it->second.is_patch && !a_it->second.is_block_member,
                             consumer_stage->arrayed_input && !b_it->second.is_patch && !b_it->second.is_block_member, true)) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
                                SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, ""SC"", ""Type mismatch on location %u.%u: '%s' vs '%s'"",
                                a_first.first, a_first.second, describe_type(producer, a_it->second.type_id).c_str(),
                                describe_type(consumer, b_it->second.type_id).c_str());
            }
            if (a_it->second.is_patch != b_it->second.is_patch) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
                                SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, ""SC"",
                                ""Decoration mismatch on location %u.%u: is per-%s in %s stage but ""
                                    ""per-%s in %s stage"",
                                a_first.first, a_first.second, a_it->second.is_patch ? ""patch"" : ""vertex"", producer_stage->name,
                                b_it->second.is_patch ? ""patch"" : ""vertex"", consumer_stage->name);
            }
            if (a_it->second.is_relaxed_precision != b_it->second.is_relaxed_precision) {
                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0, __LINE__,
                                SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, ""SC"",
                                ""Decoration mismatch on location %u.%u: %s and %s stages differ in precision"", a_first.first,
                                a_first.second, producer_stage->name, consumer_stage->name);
            }
            a_it++;
            b_it++;
        }
    }

    return skip;
}

// Validate that the shaders used by the given pipeline and store the active_slots
//  that are actually used by the pipeline into pPipeline->active_slots
bool validate_and_capture_pipeline_shader_state(layer_data *dev_data, PIPELINE_STATE *pipeline) {
    auto pCreateInfo = pipeline->graphicsPipelineCI.ptr();
    int vertex_stage = get_shader_stage_id(VK_SHADER_STAGE_VERTEX_BIT);
    int fragment_stage = get_shader_stage_id(VK_SHADER_STAGE_FRAGMENT_BIT);
    auto report_data = GetReportData(dev_data);

    shader_module const *shaders[5];
    memset(shaders, 0, sizeof(shaders));
    spirv_inst_iter entrypoints[5];
    memset(entrypoints, 0, sizeof(entrypoints));
    bool skip = false;

    for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
        auto pStage = &pCreateInfo->pStages[i];
        auto stage_id = get_shader_stage_id(pStage->stage);
        skip |= validate_pipeline_shader_stage(dev_data, pStage, pipeline, &shaders[stage_id], &entrypoints[stage_id]);
    }

    // if the shader stages are no good individually, cross-stage validation is pointless.
    if (skip) return true;

    auto vi = pCreateInfo->pVertexInputState;

    if (vi) {
        skip |= validate_vi_consistency(report_data, vi);
    }

    if (shaders[vertex_stage] && shaders[vertex_stage]->has_valid_spirv) {
        skip |= validate_vi_against_vs_inputs(report_data, vi, shaders[vertex_stage], entrypoints[vertex_stage]);
    }

    int producer = get_shader_stage_id(VK_SHADER_STAGE_VERTEX_BIT);
    int consumer = get_shader_stage_id(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);

    while (!shaders[producer] && producer != fragment_stage) {
        producer++;
        consumer++;
    }

    for (; producer != fragment_stage && consumer <= fragment_stage; consumer++) {
        assert(shaders[producer]);
        if (shaders[consumer] && shaders[consumer]->has_valid_spirv && shaders[producer]->has_valid_spirv) {
            skip |= validate_interface_between_stages(report_data, shaders[producer], entrypoints[producer],
                                                      &shader_stage_attribs[producer], shaders[consumer], entrypoints[consumer],
                                                      &shader_stage_attribs[consumer]);

            producer = consumer;
        }
    }

    if (shaders[fragment_stage] && shaders[fragment_stage]->has_valid_spirv) {
        skip |= validate_fs_outputs_against_render_pass(report_data, shaders[fragment_stage], entrypoints[fragment_stage],
                                                        pipeline, pCreateInfo->subpass);
    }

    return skip;
}

bool validate_compute_pipeline(layer_data *dev_data, PIPELINE_STATE *pipeline) {
    auto pCreateInfo = pipeline->computePipelineCI.ptr();

    shader_module const *module;
    spirv_inst_iter entrypoint;

    return validate_pipeline_shader_stage(dev_data, &pCreateInfo->stage, pipeline, &module, &entrypoint);
}

bool PreCallValidateCreateShaderModule(layer_data *dev_data, VkShaderModuleCreateInfo const *pCreateInfo, bool *spirv_valid) {
    bool skip = false;
    spv_result_t spv_valid = SPV_SUCCESS;
    auto report_data = GetReportData(dev_data);

    if (GetDisables(dev_data)->shader_validation) {
        return false;
    }

    auto have_glsl_shader = GetEnabledExtensions(dev_data)->vk_nv_glsl_shader;

    if (!have_glsl_shader && (pCreateInfo->codeSize % 4)) {
        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                        __LINE__, VALIDATION_ERROR_12a00ac0, ""SC"",
                        ""SPIR-V module not valid: Codesize must be a multiple of 4 but is "" PRINTF_SIZE_T_SPECIFIER "". %s"",
                        pCreateInfo->codeSize, validation_error_map[VALIDATION_ERROR_12a00ac0]);
    } else {
        // Use SPIRV-Tools validator to try and catch any issues with the module itself
        spv_context ctx = spvContextCreate(SPV_ENV_VULKAN_1_0);
        spv_const_binary_t binary{ pCreateInfo->pCode, pCreateInfo->codeSize / sizeof(uint32_t) };
        spv_diagnostic diag = nullptr;

        spv_valid = spvValidate(ctx, &binary, &diag);
        if (spv_valid != SPV_SUCCESS) {
            if (!have_glsl_shader || (pCreateInfo->pCode[0] == spv::MagicNumber)) {
                skip |= log_msg(report_data,
                                spv_valid == SPV_WARNING ? VK_DEBUG_REPORT_WARNING_BIT_EXT : VK_DEBUG_REPORT_ERROR_BIT_EXT,
                                VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__, SHADER_CHECKER_INCONSISTENT_SPIRV, ""SC"",
                                ""SPIR-V module not valid: %s"", diag && diag->error ? diag->error : ""(no error text)"");
            }
        }

        spvDiagnosticDestroy(diag);
        spvContextDestroy(ctx);
    }

    *spirv_valid = (spv_valid == SPV_SUCCESS);
    return skip;
}
",16189,True,2776.09646175343,median
"== Batch Programming Model

The batch programming model is described by interfaces, abstract
classes, and field annotations. Interfaces define the essential contract
between batch applications and the batch runtime. Most interfaces have a
corresponding abstract class that provides default implementations of
certain methods for developer convenience.

=== Steps

A batch step is either chunk or batchlet.

==== Chunk

A chunk type step performs item-oriented processing using a
reader-processor-writer batch pattern and does checkpointing.

===== ItemReader Interface

An ItemReader is used to read items for a chunk step. ItemReader is one
of the three batch artifact types that comprise a chunk type step. The
other two are ItemProcessor and ItemWriter.

The ItemReader interface may be used to implement an ItemReader batch
artifact:

[[app-listing.ItemReader.java]]
[source,java]
.ItemReader.java
----
package jakarta.batch.api.chunk;

import java.io.Serializable;

/*
 * ItemReader defines the batch artifact that reads
 * items for chunk processing.
 */
public interface ItemReader {
  /**
   * The open method prepares the reader to read items
   * The input parameter represents the last checkpoint
   * for this reader in a given job instance. The
   * checkpoint data is defined by this reader and is
   * provided by the checkpointInfo method. The checkpoint
   * data provides the reader whatever information it needs
   * to resume reading items upon restart. A checkpoint value
   * of null is passed upon initial start.
   *
   * @param checkpoint specifies the last checkpoint
   * @throws Exception is thrown for any errors.
   */
  public void open(Serializable checkpoint) throws Exception;

  /**
   * The close method marks the end of use of the
   * ItemReader. The reader is free to do any cleanup
   * necessary.
   * @throws Exception is thrown for any errors.
   */
  public void close() throws Exception;

  /**
   * The readItem method returns the next item
   * for chunk processing.
   * It returns null to in dicate no more items, which
   * also means the current chunk will be committed and
   * the step will end.
   * @return next item or null
   * @throws Exception is thrown for any errors.
   */
  public Object readItem() throws Exception;

  /**
   * The checkpointInfo method returns the current
   * checkpoint data for this reader. It is
   * called before a chunk checkpoint is committed.
   * @return checkpoint data
   * @throws Exception is thrown for any errors.
   */
  public Serializable checkpointInfo() throws Exception;
}
----

[[app-listing.AbstractItemReader.java]]
[source,java]
.AbstractItemReader.java
----
package jakarta.batch.api.chunk;
import java.io.Serializable;
public abstract class AbstractItemReader implements ItemReader
{
    @Override
    public void open(Serializable checkpoint)throws Exception {
    }

    @Override
    public void close()throws Exception {
    }

    @Override
    public abstract Object readItem() throws Exception;

    @Override
    public Serializable checkpointInfo() throws Exception {
        return null;
    }
}
----


===== ItemProcessor Interface

An ItemProcessor is used to process items for a chunk step.
ItemProcessor is one of the three batch artifact types that comprise a
chunk type step. An ItemProcessor is an optional artifact on a chunk
type step. The other two are ItemReader and ItemWriter.

The ItemProcessor interface may be used to implement an ItemProcessor
batch artifact:

[[app-listing.ItemProcessor.java]]
[source,java]
.ItemProcessor.java
----
package jakarta.batch.api.chunk;
/**
* ItemProcessor is used in chunk processing
* to operate on an input item and produce
* an output item.
*
*/
public interface ItemProcessor {
    /**
    * The processItem method is part of a chunk
    * step. It accepts an input item from an
    * item reader and returns an item that gets
    * passed onto the item writer. Returning null
    * indicates that the item should not be continued
    * to be processed. This effectively enables processItem
    * to filter out unwanted input items.
    * @param item specifies the input item to process.
    * @return output item to write.
    * @throws Exception thrown for any errors.
    */
    public Object processItem(Object item) throws Exception;
}
----

===== ItemWriter Interface

An ItemWriter is used to write a list of output items for a chunk step.
ItemWriter is one of the three batch artifact types that comprise a
chunk type step. The other two are ItemProcessor and ItemReader.

The ItemWriter interface may be used to implement an ItemWriter batch
artifact:

[[app-listing.ItemWriter.java]]
[source,java]
.ItemWriter.java
----
package jakarta.batch.api.chunk;
import java.io.Serializable;
import java.util.List;
/**
*
* ItemWriter defines the batch artifact that writes to a
* list of items for chunk processing.
*
*/
public interface ItemWriter {
    /**
    * The open method prepares the writer to write items.
    *
    * The input parameter represents the last checkpoint
    * for this writer in a given job instance. The
    * checkpoint data is defined by this writer and is
    * provided by the checkpointInfo method. The checkpoint
    * data provides the writer whatever information it needs
    * to resume writing items upon restart. A checkpoint value
    * of null is passed upon initial start.
    *
    * @param checkpoint specifies the last checkpoint
    * @throws Exception is thrown for any errors.
    */
    public void open(Serializable checkpoint) throws Exception;
    /**
    * The close method marks the end of use of the
    * ItemWriter. The writer is free to do any cleanup
    * necessary.
    * @throws Exception is thrown for any errors.
    */
    public void close() throws Exception;
    /**
    * The writeItems method writes a list of item
    * for the current chunk.
    * @param items specifies the list of items to write.
    * This may be an empty list (e.g. if all the
    * items have been filtered out by the
    * ItemProcessor).
    * @throws Exception is thrown for any
    errors.
    */
    public void writeItems(List<Object> items) throws Exception;
    /**
    * The checkpointInfo method returns the current
    * checkpoint data for this writer. It is
    * called before a chunk checkpoint is committed.
    * @return checkpoint data
    * @throws Exception is thrown for any errors.
    */
    public Serializable checkpointInfo() throws Exception;
}
----

[[app-listing.AbstractItemWriter.java]]
[source,java]
.AbstractItemWriter.java
----
package jakarta.batch.api.chunk;
import java.io.Serializable;
import java.util.List;
/**
* The AbstractItemWriter provides default implementations
* of not commonly implemented methods.
*/
public abstract class AbstractItemWriter implements ItemWriter
{
    /**
    * Override this method if the ItemWriter requires
    * any open time processing.
    * The default implementation does nothing.
    *
    * @param last checkpoint for this ItemReader
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void open(Serializable checkpoint) throws Exception {
    }
    /**
    * Override this method if the ItemWriter requires
    * any close time processing.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void close() throws Exception {
    }
    /**
    * Implement write logic for the ItemWriter in this
    * method.
    *
    * @param items specifies the list of items to write.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public abstract void writeItems(List<Object> items) throws
    Exception;
    /**
    * Override this method if the ItemWriter supports
    * checkpoints.
    * The default implementation returns null.
    *
    * @return checkpoint data
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public Serializable checkpointInfo() throws Exception {
        return null;
    }
}
----

===== CheckpointAlgorithm Interface

A CheckpointAlgorithm implements a custom checkpoint policy for a chunk
step. The CheckpointAlgorithm interface may be used to implement an
CheckpointAlgorithm batch artifact:

[[app-listing.CheckpointAlgorithm.java]]
[source,java]
.CheckpointAlgorithm.java
----
package jakarta.batch.api.chunk;
/**
* CheckpointAlgorithm provides a custom checkpoint
* policy for chunk steps.
*
*/
public interface CheckpointAlgorithm {
    /**
    * The checkpointTimeout is invoked at the beginning of a new
    * checkpoint interval for the purpose of establishing the checkpoint
    * timeout.
    * It is invoked before the next chunk transaction begins. This
    * method returns an integer value, which is the timeout value
    * (expressed in seconds) which will be used for the next chunk
    * transaction.
    * This method is useful to automate the setting of the
    * checkpoint timeout based on factors known outside the job
    * definition.
    * A value of '0' signifies no maximum established by this
    * CheckpointAlgorithm, i.e. the maximum permissible timeout allowed by
    * the runtime environment.
    * @return the timeout interval (expressed in seconds)
    * to use for the next checkpoint interval
    * @throws Exception thrown for any errors.
    */
    public int checkpointTimeout() throws Exception;
    /**
    * The beginCheckpoint method is invoked before the
    * next checkpoint interval begins (before the next
    * chunk transaction begins).
    * @throws Exception thrown for any errors.
    */
    public void beginCheckpoint() throws Exception;
    /**
    * The isReadyToCheckpoint method is invoked by
    * the batch runtime after each item is processed
    * to determine if now is the time to checkpoint
    * the current chunk.
    * @return boolean indicating whether or not
    * to checkpoint now.
    * @throws Exception thrown for any errors.
    */
    public boolean isReadyToCheckpoint() throws Exception;
    /**
    * The endCheckpoint method is invoked after the
    * last checkpoint is taken (after the chunk
    * transaction is committed).
    * @throws Exception thrown for any errors.
    */
    public void endCheckpoint() throws Exception;
}
----

[[app-listing.AbstractCheckpointAlgorithm.java]]
[source,java]
.AbstractCheckpointAlgorithm.java
----
package jakarta.batch.api.chunk;
/**
* The AbstractCheckpointAlgorithm provides default
* implementations of less commonly implemented
* methods.
*/
public abstract class AbstractCheckpointAlgorithm implements
CheckpointAlgorithm {
    /**
    * Override this method if the CheckpointAlgorithm
    * establishes a checkpoint timeout.
    * The default implementation returns 0, which means
    * the maximum permissible timeout allowed by the
    * runtime environment.
    *
    * @return the timeout interval (expressed in seconds)
    * to use for the next checkpoint interval
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public int checkpointTimeout() throws Exception {
        return 0;
    }
    /**
    * Override this method for the CheckpointAlgorithm
    * to do something before a checkpoint interval
    * begins (before the next chunk transaction begins).
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beginCheckpoint() throws Exception {
    }
    /**
    * Implement logic in this method
    * to decide if a checkpoint should be taken now.
    *
    * @return boolean indicating whether or not
    * to checkpoint now.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public abstract boolean isReadyToCheckpoint() throws Exception;
    /**
    * Override this method for the CheckpointAlgorithm
    * to do something after a checkpoint is taken (after
    * the chunk transaction is committed).
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void endCheckpoint() throws Exception {
    }
}
----

==== Batchlet Interface
A Batchlet-type step implements a roll your own batch pattern. This
batch pattern is invoked once, runs to completion, and returns an exit
status.

The Batchlet interface may be used to implement a Batchlet batch
artifact:

[[app-listing.Batchlet.java]]
[source,java]
.Batchlet.java
----
package jakarta.batch.api;
/**
*
* A batchlet is type of batch step
* that can be used for any type of
* background processing that does not
* explicitly call for a chunk oriented
* approach.
* <p>
* A well-behaved batchlet responds
* to stop requests by implementing
* the stop method.
*
*/
public interface Batchlet {
    /**
    * The process method does the work
    * of the batchlet. If this method
    * throws an exception, the batchlet
    * step ends with a batch status of
    * FAILED.
    * @return exit status string
    * @throws Exception if an error occurs.
    */
    public String process() throws Exception;
    /**
    * The stop method is invoked by the batch
    * runtime as part of JobOperator.stop()
    * method processing. This method is invoked
    * on a thread other than the thread on which
    * the batchlet process method is running.
    *
    * @throws Exception if an error occurs.
    */
    public void stop() throws Exception;
}
----

[[app-listing.AbstractBatchlet.java]]
[source,java]
.AbstractBatchlet.java
----
package jakarta.batch.api;
/**
* The AbstractBatchlet provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractBatchlet implements Batchlet {
    /**
    * Implement process logic for the Batchlet in this
    * method.
    *
    * @return exit status string
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public abstract String process() throws Exception;
    /**
    * Override this method if the Batchlet will
    * end in response to the JobOperator.stop()
    * operation.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void stop() throws Exception {
    }
}
----

TIP: A well designed batchlet stops gracefully when the JobOperator.stop operation is invoked.  
See section xref:stop-processing[11.13] for further information about stop processing.

=== Listeners
Use Listeners to interpose on batch execution.

==== JobListener Interface
A job listener receives control before and after a job execution runs,
and also if an exception is thrown during job processing. The
JobListener interface may be used to implement an JobListener batch
artifact:

[[app-listing.JobListener.java]]
[source,java]
.JobListener.java
----
package jakarta.batch.api.listener;
/**
* JobListener intercepts job execution.
*
*/
public interface JobListener {
    /**
    * The beforeJob method receives control
    * before the job execution begins.
    * @throws Exception throw if an error occurs.
    */
    public void beforeJob() throws Exception;
    /**
    * The afterJob method receives control
    * after the job execution ends.
    * @throws Exception throw if an error occurs.
    */
    public void afterJob() throws Exception;
}
----

[[app-listing.AbstractJobListener.java]]
[source,java]
.AbstractJobListener.java
----
package jakarta.batch.api.listener;
/**
* The AbstractJobListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractJobListener implements JobListener
{
    /**
    * Override this method if the JobListener
    * will do something before the job begins.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeJob() throws Exception {
    }
    /**
    * Override this method if the JobListener
    * will do something after the job ends.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterJob() throws Exception {
    }
}
----


==== StepListener Interface
A step listener can receive control before and after a step runs, and
also if an exception is thrown during step processing. The StepListener
interface may be used to implement an StepListener batch artifact:

[[app-listing.StepListener.java]]
[source,java]
.StepListener.java
----
package jakarta.batch.api.listener;
/**
* StepListener intercepts step execution.
*
*/
public interface StepListener {
    /**
    * The beforeStep method receives control
    * before a step execution begins.
    * @throws Exception throw if an error occurs.
    */
    public void beforeStep() throws Exception;
    /**
    * The afterStep method receives control
    * after a step execution ends.
    * @throws Exception throw if an error occurs.
    */
    public void afterStep() throws Exception;
}
----

[[app-listing.AbstractStepListener.java]]
[source,java]
.AbstractStepListener.java
----
package jakarta.batch.api.listener;
/**
* The AbstractStepListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractStepListener implements
StepListener {
    /**
    * Override this method if the StepListener
    * will do something before the step begins.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeStep() throws Exception {
    }
    /**
    * Override this method if the StepListener
    * will do something after the step ends.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterStep() throws Exception {
    }
}
----


==== ChunkListener Interface
A chunk listener can receive control at the beginning and the end of
chunk, and upon an exception thrown back to the runtime implementation.
The ChunkListener interface may be used to implement a ChunkListener
batch artifact:

[[app-listing.ChunkListener.java]]
[source,java]
.ChunkListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* ChunkListener intercepts chunk processing.
*
*/
public interface ChunkListener {
    /**
    * The beforeChunk method receives control
    * before processing of the next
    * chunk begins. This method is invoked
    * in the same transaction as the chunk
    * processing.
    * @throws Exception throw if an error occurs.
    */
    public void beforeChunk() throws Exception;
    /**
    * The onError method receives control
    * before the chunk transaction is rolled back.
    * Note afterChunk is not invoked in this case.
    * @param ex specifies the exception that
    * caused the roll back.
    * @throws Exception throw if an error occurs.
    */
    public void onError(Exception ex) throws Exception;
    /**
    * The afterChunk method receives control
    * after processing of the current
    * chunk ends. This method is invoked
    * in the same transaction as the chunk
    * processing.
    * @throws Exception throw if an error occurs.
    */
    public void afterChunk() throws Exception;
}
----

[[app-listing.AbstractChunkListener.java]]
[source,java]
.AbstractChunkListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* The AbstractChunkListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractChunkListener implements
ChunkListener {
    /**
    * Override this method if the ChunkListener
    * will do something before the chunk begins.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeChunk() throws Exception {
    }
    /**
    * Override this method if the ChunkListener will do
    * something before the chunk transaction is rolled back.
    * Note afterChunk is not invoked in this case.
    * @param ex specifies the exception that
    * caused the roll back.
    * @throws Exception (or subclass) throw if an error occurs.
    */
    @Override
    public void onError(Exception ex) throws Exception {
    }
    /**
    * Override this method if the ChunkListener
    * will do something after the chunk ends.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterChunk() throws Exception {
    }
}
----


==== ItemReadListener Interface
An item read listener can receive control before and after an item is
read by an item reader, and also if the reader throws an exception. The
ItemReadListener interface may be used to implement an ItemReadListener
batch artifact:

[[app-listing.ItemReadListener.java]]
[source,java]
.ItemReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* ItemReadListener intercepts item reader
* processing.
*
*/
public interface ItemReadListener {
    /**
    * The beforeRead method receives control
    * before an item reader is called to read the next item.
    * @throws Exception is thrown if an error occurs.
    */
    public void beforeRead() throws Exception;
    /**
    * The afterRead method receives control after an item
    * reader reads an item. The method receives the item read as
    * an input.
    * @param item specifies the item read by the item reader.
    * @throws Exception is thrown if an error occurs.
    */
    public void afterRead(Object item) throws Exception;
    /**
    * The onReadError method receives control after an item reader
    * throws an exception in the readItem method.
    * This method receives the exception as an input.
    * @param ex specifies the exception that occurred in the item reader.
    * @throws Exception is thrown if an error occurs.
    */
    public void onReadError(Exception ex) throws Exception;
}
----

[[app-listing.AbstractItemReadListener.java]]
[source,java]
.AbstractItemReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* The AbstractItemReadListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractItemReadListener implements
ItemReadListener {
    /**
    * Override this method if the ItemReadListener
    * will do something before the item is read.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeRead() throws Exception {
    }
    /**
    * Override this method if the ItemReadListener
    * will do something after the item is read.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterRead(Object item) throws Exception {
    }
    /**
    * Override this method if the ItemReadListener
    * will do something when the ItemReader readItem
    * method throws an exception.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void onReadError(Exception ex) throws Exception {
    }
}
----



==== ItemProcessListener Interface
An item processor listener can receive control before and after an item
is processed by an item processor, and also if the processor throws an
exception. The ItemProcessListener interface may be used to implement an
ItemProcessListener batch artifact:


[[app-listing.ItemProcessListener.java]]
[source,java]
.ItemProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* ItemProcessListener intercepts item processing.
*
*/
public interface ItemProcessListener {
    /**
    * The beforeProcess method receives control before
    * an item processor is called to process the next item.
    * The method receives the item to be processed as an input.
    * @param item specifies the item about to be processed.
    * @throws Exception if an error occurs.
    */
    public void beforeProcess(Object item) throws Exception;
    /**
    * The afterProcess method receives control after an item
    * processor processes an item. The method receives the item processed
    * and the result item as an input.
    * @param item specifies the item processed by the item processor.
    * @param result specifies the item to pass to the item writer.
    * @throws Exception if an error occurs.
    */
    public void afterProcess(Object item, Object result) throws
    Exception;
    /**
    * The onProcessError method receives control after an
    * item processor processItem throws an exception. The method
    * receives the item sent to the item processor as input.
    * @param item specifies the item the processor attempted to process.
    * @param ex specifies the exception thrown by the item processor.
    * @throws Exception if an error occurs
    */
    public void onProcessError(Object item, Exception ex) throws
    Exception;
}
----

[[app-listing.AbstractItemProcessListener.java]]
[source,java]
.AbstractItemProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* The AbstractItemProcessListener provides default
* implementations of less commonly implemented methods.
*
*/
public abstract class AbstractItemProcessListener implements
ItemProcessListener {
    /**
    * Override this method if the ItemProcessListener
    * will do something before the item is processed.
    * The default implementation does nothing.
    *
    * @param item specifies the item about to be processed.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeProcess(Object item) throws Exception {
    }
    /**
    * Override this method if the ItemProcessListener
    * will do something after the item is processed.
    * The default implementation does nothing.
    *
    * @param item specifies the item about to be processed.
    * @param result specifies the item to pass to the item writer.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterProcess(Object item, Object result) throws
    Exception {
    }
    /**
    * Override this method if the ItemProcessListener
    * will do something when the ItemProcessor processItem
    * method throws an exception.
    * The default implementation does nothing.
    *
    * @param item specifies the item about to be processed.
    * @param ex specifies the exception thrown by the item processor.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void onProcessError(Object item, Exception ex) throws
    Exception {
    }
}
----




==== ItemWriteListener Interface
A item write listener can receive control before and after an item is
written by an item writer, and also if the writer throws an exception.
The ItemWriteListener interface may be used to implement an
ItemWriteListener batch artifact:

[[app-listing.ItemWriteListener.java]]
[source,java]
.ItemWriteListener.java
----
package jakarta.batch.api.chunk.listener;
import java.util.List;
/**
* ItemWriteListener intercepts item writer
* processing.
*
*/
public interface ItemWriteListener {
    /**
    * The beforeWrite method receives control before
    * an item writer is called to write its items. The
    * method receives the list of items sent to the item
    * writer as an input.
    * @param items specifies the items about to be
    * written.
    * @throws Exception is thrown if an error occurs.
    */
    public void beforeWrite(List<Object> items) throws Exception;
    /**
    * The afterWrite method receives control after an
    * item writer writes its items. The method receives the
    * list of items sent to the item writer as an input.
    * @param items specifies the items written by the item writer.
    * @throws Exception is thrown if an error occurs.
    */
    public void afterWrite(List<Object> items) throws Exception;
    /**
    * The onWriteError method receives control after an
    * item writer writeItems throws an exception. The method
    * receives the list of items sent to the item writer as input.
    * @param items specifies the items which the item writer
    * attempted to write.
    * @param ex specifies the exception thrown by the item
    * writer.
    * @throws Exception is thrown if an error occurs.
    */
    public void onWriteError(List<Object> items, Exception ex) throws
    Exception;
}
----

==== Skip Listener Interfaces
A skip listener can receive control when a skippable exception is
thrown from an item reader, processor, or writer. Three interfaces are
provided to implement these listeners:

[[app-listing.SkipReadListener.java]]
[source,java]
.SkipReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* SkipReadListener intercepts skippable
* itemReader exception handling.
*/
public interface SkipReadListener {
    /**
    * The onSkipReadItem method receives control
    * when a skippable exception is thrown from an
    * ItemReader readItem method. This method receives the
    * exception as an input.
    * @param ex specifies the exception thrown by the ItemReader.
    * @throws Exception is thrown if an error occurs.
    */
    public void onSkipReadItem(Exception ex) throws Exception;
}
----

[[app-listing.SkipProcessListener.java]]
[source,java]
.SkipProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* SkipProcessListener intercepts skippable
* itemProcess exception handling.
*/
public interface SkipProcessListener {
    /**
    * The onSkipProcessItem method receives control when
    * a skippable exception is thrown from an ItemProcess
    * processItem method.
    * This method receives the exception and the item to process
    * as an input.
    * @param item specifies the item passed to the ItemProcessor.
    * @param ex specifies the exception thrown by the
    * ItemProcessor.
    * @throws Exception is thrown if an error occurs.
    */
    public void onSkipProcessItem(Object item, Exception ex) throws
    Exception;
}
----

[[app-listing.SkipWriteListener.java]]
[source,java]
.SkipWriteListener.java
----
package jakarta.batch.api.chunk.listener;
import java.util.List;
/**
* SkipWriteListener intercepts skippable
* itemWriter exception handling.
*/
public interface SkipWriteListener {
    /**
    * The onSkipWriteItems method receives control when a
    * skippable exception is thrown from an ItemWriter
    * writeItems method. This
    * method receives the exception and the items that were
    * skipped as an input.
    * @param items specifies the list of item passed to the
    * item writer.
    * @param ex specifies the exception thrown by the
    * ItemWriter.
    * @throws Exception is thrown if an error occurs.
    */
    public void onSkipWriteItem(List<Object> items, Exception ex)
    throws Exception;
}
----

==== RetryListener Interface

A retry listener can receive control when a retryable exception is
thrown from an item reader, processor, or writer. Three interfaces are
provided to implement these listeners:

[[app-listing.RetryReadListener.java]]
[source,java]
.RetryReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* RetryReadListener intercepts retry processing for
* an ItemReader.
*/
public interface RetryReadListener {
    /**
    * The onRetryReadException method receives control
    * when a retryable exception is thrown from an ItemReader
    * readItem method.
    * This method receives the exception as input. This method
    * receives control in the same checkpoint scope as the
    * ItemReader. If this method throws a an exception, the job
    * ends in the FAILED state.
    * @param ex specifies the exception thrown by the item
    * reader.
    * @throws Exception is thrown if an error occurs.
    */
    public void onRetryReadException(Exception ex) throws Exception;
}
----

[[app-listing.RetryProcessListener.java]]
[source,java]
.RetryProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* RetryProcessListener intercepts retry processing for
* an ItemProcessor.
*
*/
public interface RetryProcessListener {
    /**
    * The onRetryProcessException method receives control
    * when a retryable exception is thrown from an ItemProcessor
    * processItem method. This method receives the exception and the item
    * being processed as inputs. This method receives control in same
    * checkpoint scope as the ItemProcessor. If this method
    * throws a an exception, the job ends in the FAILED state.
    * @param item specifies the item passed to the ItemProcessor.
    * @param ex specifies the exception thrown by the ItemProcessor.
    * @throws Exception is thrown if an error occurs.
    */
    public void onRetryProcessException(Object item, Exception ex)
    throws Exception;
}
----


[[app-listing.RetryWriteListener.java]]
[source,java]
.RetryWriteListener.java
----
package jakarta.batch.api.chunk.listener;
import java.util.List;
/**
* RetryWriteListener intercepts retry processing for
* an ItemWriter.
*
*/
public interface RetryWriteListener {
    /**
    * The onRetryWriteException method receives control when a
    * retryable exception is thrown from an ItemWriter writeItems
    * method. This method receives the exception and the list of items
    * being written as inputs.
    * This method receives control in same checkpoint scope as the
    * ItemWriter. If this method throws a an exception, the job ends
    * in the FAILED state.
    * @param items specify the items passed to an item writer.
    * @param ex specifies the exception thrown by an item
    * writer.
    * @throws Exception is thrown if an error occurs.
    */
    public void onRetryWriteException(List<Object> items, Exception ex)
    throws Exception;
}
----

=== Batch Properties

Batch applications need a way to receive parameters when a job is
initiated for execution. Properties can be defined by batch programming
model artifacts, then have values passed to them when a job is
initiated. Batch properties are string values.

Note batch properties are visible only in the scope in which they are
defined (see Section xref:scope-of-property-definitions-for-batchproperty-injection[9.3.2]). However batch properties values can be
formed from other properties according to Job XML Substitution Rules.
See section xref:job-xml-substitution[8.8] for further information on substitution.

==== @BatchProperty

The @BatchProperty annotation identifies a class field injection as a
batch property. A batch property has a name (name) and default value.
The @BatchProperty may be used on a class field for any class identified
as a batch programming model artifact -E.g. ItemReader, ItemProcessor,
JobListener, etc..

@BatchProperty must be used with the standard @Inject annotation
(jakarta.inject.Inject). @BatchProperty is used to assign batch artifact
property values from Job XML to the batch artifact itself.

A field annotated with the @BatchProperty annotation must not be static
and must not be final.

Note: the batch runtime must ensure @Inject works with @BatchProperty,
whether or not the execution environment includes an implementation of
Jakarta Dependency Injection.   The batch properties must always be
injected, and depending on the specific dependency injection technology
used, other injections may or may not also be supported.

Syntax:

[[app-listing.batchProperty]]
[source,java]
----
 package: jakarta.batch.api

 @Inject @BatchProperty(name=""<property-name>"") String <field-name>;
----

Where:

[width=""100%"",cols=""<50%,<50%"",]
|=======================================================================
|<property-name> |is the optional name of this batch property. The
default is the Java field name.

|<field-name> |is the field name of the batch property.
|=======================================================================

[[app-listing.BatchProperty.java]]
[source,java]
.BatchProperty.java
----
package jakarta.batch.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import jakarta.enterprise.util.Nonbinding;
import jakarta.inject.Qualifier;
/**
* Annotation used by batch artifacts to declare a
* field which is injectable via a JSL-defined value
* (possibly leveraging Job XML substitutions).
*
*/
@Qualifier
@Target({
    ElementType._FIELD_, ElementType._METHOD_,
    ElementType._PARAMETER_
}
)
@Retention(RetentionPolicy._RUNTIME_)
public @interface BatchProperty {
    @Nonbinding
    public String name() default """";
}
----

The value of the annotated field is assigned by the batch runtime if a
corresponding property element with a matching name is specified in the
JSL in the scope that applies to the batch artifact in question. If the
JSL property value resolves to the empty string (either explicitly set
to the empty string literal or resolving to an empty string via property
substitution, as described in section xref:job-xml-substitution[8.8]), no assignment is made and the resulting
value is undefined by the batch specification. The resulting value might
simply be the Java default value, however using various dependency
injection technologies may produce different results. The resultant
behavior may be defined by the particular dependency injection
technology used in the runtime environment and so is outside the scope
of this specification.
Example:

[[app-listing.BatchPropertySample]]
[source,java]
----
 import jakarta.inject.Inject;
 import jakarta.batch.api.BatchProperty;
 public class MyItemReaderImpl {

@Inject @BatchProperty String fname;

}
----

Behavior:

When the batch runtime instantiates the batch artifact (item reader in
this example), it assigns the

value of the property with name equal to fname provided in the job XML
to the corresponding @BatchProperty field named fname. If no value is
defined in JSL, the Java default (null) is assigned or some other
default is provided by a particular dependency injection technology.

==== Scope of property definitions for @BatchProperty Injection

The rules governing the definition of properties for injection via
@BatchProperty deserve some extra explanation and an example.

For a given artifact, the only properties that are injectable via
@BatchProperty are those which are defined at the level of the artifact
itself (i.e. as children of the ""properties"" element which is in turn a
child of the very element defining the artifact: batchlet, reader,
listener, etc.).

In particular, just because an artifact definition is contained (at some
level of nesting) within a job element and (for most artifacts) within a
step element as well, it is NOT the case that the job properties and
step properties are themselves injectable into that artifact via
@BatchProperty. This is the case even though these job and step
properties are available for resolving the artifact-level property
definitions via the jobProperties substitution mechanism (see section
 xref:jobproperties-substitution-operator[8.8.1.2]) .



The following example should make this more clear:

[[app-listing.BatchPropertyXML]]
[source,xml]
.Example JSL
----
<job>
 <properties>
 <property name=""x"" value=""xVal""/>
 ...
 <step id=""step1"">
  <batchlet ref=""MyBatchlet"">
   <properties>
    <property name=""y"" value=""#\\{jobProperties['x']}""/>
   </properties>

----

*Example Java (MyBatchlet from JSL above):*

[[app-listing.BadBatchProperty]]
[source,java]
----
 // WONT WORK! - There is no property 'x' in scope for this injection
 @Inject @BatchProperty(name=""x"");

 // WILL WORK – Gets value 'xVal'
 @Inject @BatchProperty(name=""y"");
----

=== Batch Contexts

Context objects are supplied by the batch runtime and provide important
functions to a batch application. Contexts provide information about the
running batch job, provide a place for a batch job to store interim
values, and provide a way for the batch application to communicate
important information back to the batch runtime. Contexts can be
injected into an application as member variables. There is a context for
both job and step. The job context represents the entire job. The step
context represents the current step executing within the job.

==== Batch Contexts
Batch artifact access to batch contexts is by injection using the
standard @Inject annotation (jakarta.inject.Inject). A field into which a
batch context is injected must not be static and must not be final.
E.g.:

 @Inject JobContext _jctxt;

 @Inject StepContext _sctxt;

The batch runtime is responsible to ensure the correct context object is
injected according to the job or step currently executing.

Note: the batch runtime must ensure @Inject works with JobContext and
StepContext, whether or not the execution environment includes an implementation of
Jakarta Dependency Injection.  The batch contexts must always be
injected, and depending on the specific dependency injection technology
used, other injections may or may not also be supported.
 See section xref:jobcontext[10.9.1] for definition of JobContext class. See section
xref:stepcontext[10.9.2] for definition of StepContext class.

===== Batch Context Lifecycle and Scope

A batch context has thread affinity and is visible only to the batch
artifacts executing on that particular thread. A batch context injected
field may be null when out of scope. Each context type has a distinct
scope and lifecycle as follows:

1.  JobContext +
+
There is one JobContext per job execution. It exists for the life of a
job. There is a distinct JobContext for each sub-thread of a parallel
execution (e.g. partitioned step).

2.  StepContext +
+
There is one StepContext per step execution. It exists for the life of
the step. For a partitioned step, there is one StepContext for the
parent step/thread; there is a distinct StepContext for each sub-thread
and each StepContext has its own distinct persistent user data for each
sub-thread.

=== Parallelization

Batch jobs may be configured to run some of their steps in parallel.
There are two supported parallelization models:

. Partitioned:
+
In the partitioned model, a step is configured to run as multiple
instances across multiple threads. Each thread runs the same step or
flow. This model is logically equivalent to launching multiple instances
of the same step. It is intended that each partition processes a
different range of the input items.
+
The partitioned model includes several optional batch artifacts to
enable finer control over parallel processing:
+
.. PartitionMapper provides a programmatic means for calculating the
number of partitions and unique properties for each.
.. PartitionReducer provides a unit of work demarcation around
partition processing.
.. PartitionCollector provides a means for merging interrim results
from individual partitions.
.. PartitionAnalyzer provides a means to gather interrim and final
results from individual partitions for single point of control
processing and decision making.

. Concurrent:
+
In the concurrent model, the flows defined by a split are configured to
run concurrently on multiple threads, one flow per thread.

==== PartitionMapper Interface
A partition mapper receives control at the start of a partitioned
execution. The partition mapper is responsible to provide unique batch
properties for each partition. The PartitionMapper interface may be used
to implement a PartitionMapper batch artifact:

[[app-listing.PartitionMapper.java]]
[source,java]
.PartitionMapper.java
----
package jakarta.batch.api.partition;
import jakarta.batch.api.partition.PartitionPlan;
/**
* PartitionMapper receives control at the start of a partitioned
* execution. A PartitionMapper is responsible to provide unique
* batch properties for each partition.
*
*/
public interface PartitionMapper {
    /**
    * The mapPartitions method that receives control at the
    * start of partitioned step processing. The method
    * returns a PartitionPlan, which specifies the batch properties
    * for each partition.
    * @return partition plan for a partitioned step.
    * @throws Exception is thrown if an error occurs.
    */
    public PartitionPlan mapPartitions( ) throws Exception;
}
----

See section xref:partitionplan[10.9.4] for details on the PartitionPlan result value type.

The PartitionMapper, when defined, is invoked upon every execution,
including restarted executions. For a full discussion of the behavior on
restart, including how to override particular details of the
PartitionPlan built by the previous execution, see section xref:batchruntime[10.8.5].

==== PartitionReducer Interface

A partition reducer provides a unit of work demarcation across
partitions. It is not a JTA transaction; no resources are enlisted.
Rather, it provides transactional flow semantics to facilitate
finalizing merge or compensation logic. The PartitionReducer interface
may be used to implement an PartitionReducer batch artifact:

[[app-listing.PartitionReducer.java]]
[source,java]
.PartitionReducer.java
----
package jakarta.batch.api.partition;
/**
* PartitionReducer provides unit of work demarcation across
* partitions. It is not a JTA transaction; no resources are
* enlisted. Rather, it provides transactional flow semantics
* to facilitate finalizing merge or compensation logic.
*
*/
public interface PartitionReducer {
    public enum PartitionStatus {
        COMMIT_, _ROLLBACK
    }
    /**
    * The beginPartitionedStep method receives
    * control at the start of partition processing.
    * It receives control before the PartitionMapper
    * is invoked and before any partitions are started.
    * @throws Exception is thrown if an error occurs.
    */
    public void beginPartitionedStep() throws Exception;
    /**
    * The beforePartitionedStepCompletion method
    * receives control at the end of partitioned
    * step processing. It receives control after all
    * partitions have completed. It does not receive
    * control if the PartitionReducer is rolling back.
    * @throws Exception is thrown if an error occurs.
    */
    public void beforePartitionedStepCompletion() throws Exception;
    /**
    * The rollbackPartitionedStep method receives
    * control if the runtime is rolling back a partitioned
    * step. Any partition threads still running are
    * allowed to complete before this method is invoked. This method
    * receives control if any of the following conditions
    * are true:
    * <p>
    * <ol>
    * <li>One or more partitions end with a Batch Status of
    * STOPPED or FAILED.</li>
    * <li>Any of the following partitioned step callbacks
    * throw an exception:</li>
    * <ol>
    * <li>PartitionMapper</li>
    * <li>PartitionReducer</li>
    * <li>PartitionCollector</li>
    * <li>PartitionAnalyzer</li>
    * </ol>
    * <li>A job with partitioned steps is restarted.</li>
    * </ol>
    * @throws Exception is thrown if an error occurs.
    */
    public void rollbackPartitionedStep() throws Exception;
    /**
    * The afterPartitionedStepCompletion method receives control
    * at the end of a partition processing. It receives a status
    * value that identifies the outcome of the partition processing.
    * The status string value is either ""COMMIT"" or ""ROLLBACK"".
    * @param status specifies the outcome of the partitioned step. Values
    * are ""COMMIT"" or ""ROLLBACK"".
    * @throws Exception is thrown if an error occurs.
    */
    public void afterPartitionedStepCompletion(PartitionStatus status)
    throws Exception;
}
----

[[app-listing.AbstractPartitionReducer.java]]
[source,java]
.AbstractPartitionReducer.java
----
package jakarta.batch.api.partition;
/**
* The AbstractPartitionReducer provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractPartitionReducer implements
PartitionReducer {
    /**
    * Override this method to take action before
    * partitioned step processing begins.
    *
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void beginPartitionedStep() throws Exception {
    }
    /**
    * Override this method to take action before
    * normal partitioned step processing ends.
    *
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void beforePartitionedStepCompletion() throws Exception {
    }
    /**
    * Override this method to take action when a
    * partitioned step is rolling back.
    *
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void rollbackPartitionedStep() throws Exception {
    }
    /**
    * Override this method to take action after
    * partitioned step processing ends.
    *
    * @param status specifies the outcome of the partitioned step.
    * Values are ""COMMIT"" or ""ROLLBACK"".
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void afterPartitionedStepCompletion(PartitionStatus status)
    throws Exception {
    }
}
----

==== PartitionCollector Interface

A partition collector provides a way to send data from individual
partitions to a single point of control running on the parent thread.
The PartitionAnalyzer is used to receive and process this data. See
section xref:partitionanalyzer-interface[9.5.4] for further information about the PartitionAnalyzer. The
PartitionCollector interface may be used to implement an
PartitionCollector batch artifact:

[[app-listing.PartitionCollector.java]]
[source,java]
.PartitionCollector.java
----
package jakarta.batch.api.partition;
import java.io.Serializable;
/**
* PartitionCollector provides a way to pass data from
* individual partitions to a single point of control running on
* the step's parent thread. The PartitionAnalyzer is used to
* receive and process this data.
*
*/
public interface PartitionCollector {
    /**
    * The collectPartitionData method receives control
    * periodically during partition processing.
    * This method receives control on each thread processing
    * a partition as follows:
    * <p>
    * <ol>
    * <li>for a chunk type step, it receives control after
    * every chunk checkpoint and then one last time at the
    * end of the partition;
    </li>
    * <li>for a batchlet type step, it receives control once
    * at the end of the batchlet.</li>
    * </ol>
    * <p>
    * Note the collector is not called if the partition
    * terminates due to an unhandled exception.
    * <p>
    * @return an Serializable object to pass to the
    * PartitionAnalyzer.
    * @throws Exception is thrown if an error occurs.
    */
    public Serializable collectPartitionData() throws Exception;
}
----

==== PartitionAnalyzer Interface

A partition analyzer receives control to process data and final results
from partitions. If a partition collector is configured on the step, the
partition analyzer receives control to process the data and results from
the partition collector. While a separate partition collector instance
is invoked on each thread processing a partition, the partition analyzer
runs on a single, consistent thread each time it is invoked. The
PartitionAnalyzer interface may be used to implement an
PartitionAnalyzer batch artifact:

[[app-listing.PartitionAnalyzer.java]]
[source,java]
.PartitionAnalyzer.java
----
package jakarta.batch.api.partition;
import java.io.Serializable;
import jakarta.batch.runtime.BatchStatus;
/**
* PartitionAnalyzer receives control to process
* data and final results from each partition. If
* a PartitionCollector is configured on the step,
* the PartitionAnalyzer receives control to process
* the data and results from the partition collector.
* While a separate PartitionCollector instance is
* invoked on each thread processing a step partition,
* a single PartitionAnalyzer instance runs on a single,
* consistent thread each time it is invoked.
*
*/
public interface PartitionAnalyzer {
    /**
    * The analyzeCollectorData method receives
    * control each time a Partition collector sends
    * its payload. It receives the
    * Serializable object from the collector as an
    * input.
    * @param data specifies the payload sent by a
    * PartitionCollector.
    * @throws Exception is thrown if an error occurs.
    */
    public void analyzeCollectorData(Serializable data) throws
    Exception;
    /**
    * The analyzeStatus method receives control each time a
    * partition ends. It receives the batch and exit
    * status strings of the partition as inputs.
    * @param batchStatus specifies the batch status of a partition.
    * @param exitStatus specifies the exit status of a partition.
    * @throws Exception is thrown if an error occurs.
    */
    public void analyzeStatus(BatchStatus batchStatus, String
    exitStatus) throws Exception;
}
----

[[app-listing.AbstractPartitionAnalyzer.java]]
[source,java]
.AbstractPartitionAnalyzer.java
----
package jakarta.batch.api.partition;
import java.io.Serializable;
import jakarta.batch.runtime.BatchStatus;
/**
* The AbstractPartitionAnalyzer provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractPartitionAnalyzer implements
PartitionAnalyzer {
    /**
    * Override this method to analyze PartitionCollector payloads.
    *
    * @param data specifies the payload sent by the
    * PartitionCollector.
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void analyzeCollectorData(Serializable data) throws
    Exception {
    }
    /**
    * Override this method to analyze partition end status.
    * @param batchStatus specifies the batch status of a partition.
    * @param exitStatus specifies the exit status of a partition.
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void analyzeStatus(BatchStatus batchStatus, String
    exitStatus)
    throws Exception {
    }
}
----


=== Decider Interface

A decider may be used to determine batch exit status and sequencing
between steps, splits, and flows in a Job XML. The decider returns a
String value which becomes the exit status value on which the decision
chooses the next transition. The Decider interface may be used to
implement an Decider batch artifact:

[[app-listing.Decider.java]]
[source,java]
.Decider.java
----
package jakarta.batch.api;
import jakarta.batch.runtime.StepExecution;
/**
* A Decider receives control as part of a decision element
* in a job. It is used to direct execution flow during job
* processing. It returns an exit status that updates the
* current job execution's exit status. This exit status
* value also directs the execution transition based on
* next, end, stop, fail child elements configured on the
* same decision element as the decider.
*/
public interface Decider {
    /**
    * The decide method sets a new exit status for a job.
    * It receives an array of StepExecution objects as input.
    * These StepExecution objects represent the execution
    * element that transitions to this decider as follows:
    * <p>
    * <ul>
    * <li>Step</li>
    * <p>
    * When the transition is from a step, the decide method
    * receives the StepExecution corresponding
    * to the step as input.
    * <li>Split</li>
    * <p>
    * When the transition is from a split, the decide method
    * receives a StepExecution from each flow defined to the split
    * as input.
    * <li>Flow</li>
    * <p>
    * When the transition is from a flow, the decide method
    * receives a StepExecution corresponding
    * to the last execution element that completed in the flow.
    * This will be a single StepExecution if the last element
    * was a step and multiple StepExecutions if the last element
    * was a split.
    * </ul>
    * @param executions specifies the StepExecution(s) of the preceding
    * element.
    * @return updated job exit status
    * @throws Exception is thrown if an error occurs.
    */
    public String decide(StepExecution[] executions) throws Exception;
}
----


=== Transactionality

Chunk type check points are transactional.  When running on a 
Jakarta EE platform, the batch runtime uses global transactions.  
In a Java SE or other environment, the batch runtime may use global 
transactions if available, otherwise the transactional behavior 
is undefined.  

Global transaction timeout is configurable at
step-level with a step-level property:

[width=""100%"",cols=""<50%,<50%"",]
|============================================
| jakarta.transaction.global.timeout | (seconds) - default is 180 (seconds)
|============================================

Example:
[source,xml]
----
 <step id=""MyGlobalStep"">
  <properties>
   <property name=""jakarta.transaction.global.timeout"" value=""600""/>
  </properties>
 </step>
----
",12123,False,2213.377704915707,median
"== FTP Component

*Available as of Camel version 1.1*

This component provides access to remote file systems over the FTP and
SFTP protocols.

When consuming from remote FTP server make sure you read the section titled _Default when consuming files_
further below for details related to consuming files.

Absolute path is *not* supported. *Camel 2.16* will translate absolute path to relative by trimming all
leading slashes from `directoryname`. There'll be WARN message printed
in the logs.

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-ftp</artifactId>
    <version>x.x.x</version>See the documentation of the Apache Commons
    <!-- use the same version as your Camel core version -->
</dependency>
-----------------------------------------------------------------------


### URI format

[source,java]
---------------------------------------------------------
ftp://[username@]hostname[:port]/directoryname[?options]
sftp://[username@]hostname[:port]/directoryname[?options]
ftps://[username@]hostname[:port]/directoryname[?options]
---------------------------------------------------------

Where *directoryname* represents the underlying directory. The directory
name is a relative path. Absolute path's is *not* supported. The
relative path can contain nested folders, such as /inbox/us.

For Camel versions before *Camel 2.16*, the directoryName *must* exist
already as this component does not support the `autoCreate` option
(which the file component does). The reason is that its the FTP
administrator (FTP server) task to properly setup user accounts, and
home directories with the right file permissions etc.

For *Camel 2.16*, `autoCreate` option is supported. When consumer
starts, before polling is scheduled, there's additional FTP operation
performed to create the directory configured for endpoint. The default
value for `autoCreate` is `true`.

If no *username* is provided, then `anonymous` login is attempted using
no password. +
 If no *port* number is provided, Camel will provide default values
according to the protocol (ftp = 21, sftp = 22, ftps = 2222).

You can append query options to the URI in the following format,
`?option=value&option=value&...`

This component uses two different libraries for the actual FTP work. FTP
and FTPS uses http://commons.apache.org/net/[Apache Commons Net] while
SFTP uses http://www.jcraft.com/jsch/[JCraft JSCH].

The FTPS component is only available in Camel 2.2 or newer. +
 FTPS (also known as FTP Secure) is an extension to FTP that adds
support for the Transport Layer Security (TLS) and the Secure Sockets
Layer (SSL) cryptographic protocols.

### URI Options

The options below are exclusive for the FTP component.


// component options: START
The FTP component has no options.
// component options: END



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

----
ftp:host:port/directoryName
----

with the following path and query parameters:

==== Path Parameters (3 parameters):

[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *host* | *Required* Hostname of the FTP server |  | String
| *port* | Port of the FTP server |  | int
| *directoryName* | The starting directory |  | String
|===

==== Query Parameters (102 parameters):

[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *binary* (common) | Specifies the file transfer mode BINARY or ASCII. Default is ASCII (false). | false | boolean
| *charset* (common) | This option is used to specify the encoding of the file. You can use this on the consumer to specify the encodings of the files which allow Camel to know the charset it should load the file content in case the file content is being accessed. Likewise when writing a file you can use this option to specify which charset to write the file as well. Do mind that when writing the file Camel may have to read the message content into memory to be able to convert the data into the configured charset so do not use this if you have big messages. |  | String
| *disconnect* (common) | Whether or not to disconnect from remote FTP server right after use. Disconnect will only disconnect the current connection to the FTP server. If you have a consumer which you want to stop then you need to stop the consumer/route instead. | false | boolean
| *doneFileName* (common) | Producer: If provided then Camel will write a 2nd done file when the original file has been written. The done file will be empty. This option configures what file name to use. Either you can specify a fixed name. Or you can use dynamic placeholders. The done file will always be written in the same folder as the original file. Consumer: If provided Camel will only consume files if a done file exists. This option configures what file name to use. Either you can specify a fixed name. Or you can use dynamic placeholders.The done file is always expected in the same folder as the original file. Only $file.name and $file.name.noext is supported as dynamic placeholders. |  | String
| *fileName* (common) | Use Expression such as File Language to dynamically set the filename. For consumers it's used as a filename filter. For producers it's used to evaluate the filename to write. If an expression is set it take precedence over the CamelFileName header. (Note: The header itself can also be an Expression). The expression options support both String and Expression types. If the expression is a String type it is always evaluated using the File Language. If the expression is an Expression type the specified Expression type is used - this allows you for instance to use OGNL expressions. For the consumer you can use it to filter filenames so you can for instance consume today's file using the File Language syntax: mydata-$date:now:yyyyMMdd.txt. The producers support the CamelOverruleFileName header which takes precedence over any existing CamelFileName header; the CamelOverruleFileName is a header that is used only once and makes it easier as this avoids to temporary store CamelFileName and have to restore it afterwards. |  | String
| *passiveMode* (common) | Sets passive mode connections. Default is active mode connections. | false | boolean
| *separator* (common) | Sets the path separator to be used. UNIX = Uses unix style path separator Windows = Uses windows style path separator Auto = (is default) Use existing path separator in file name | UNIX | PathSeparator
| *fastExistsCheck* (common) | If set this option to be true camel-ftp will use the list file directly to check if the file exists. Since some FTP server may not support to list the file directly if the option is false camel-ftp will use the old way to list the directory and check if the file exists. This option also influences readLock=changed to control whether it performs a fast check to update file information or not. This can be used to speed up the process if the FTP server has a lot of files. | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN or ERROR level and ignored. | false | boolean
| *delete* (consumer) | If true the file will be deleted after it is processed successfully. | false | boolean
| *moveFailed* (consumer) | Sets the move failure expression based on Simple language. For example to move files into a .error subdirectory use: .error. Note: When moving the files to the fail location Camel will handle the error and will not pick up the file again. |  | String
| *noop* (consumer) | If true the file is not moved or deleted in any way. This option is good for readonly data or for ETL type requirements. If noop=true Camel will set idempotent=true as well to avoid consuming the same files over and over again. | false | boolean
| *preMove* (consumer) | Expression (such as File Language) used to dynamically set the filename when moving it before processing. For example to move in-progress files into the order directory set this value to order. |  | String
| *recursive* (consumer) | If a directory will look for files in all the sub-directories as well. | false | boolean
| *sendEmptyMessageWhenIdle* (consumer) | If the polling consumer did not poll any files you can enable this option to send an empty message (no body) instead. | false | boolean
| *streamDownload* (consumer) | Sets the download method to use when not using a local working directory. If set to true the remote files are streamed to the route as they are read. When set to false the remote files are loaded into memory before being sent into the route. | false | boolean
| *directoryMustExist* (consumer) | Similar to startingDirectoryMustExist but this applies during polling recursive sub directories. | false | boolean
| *download* (consumer) | Whether the FTP consumer should download the file. If this option is set to false then the message body will be null but the consumer will still trigger a Camel Exchange that has details about the file such as file name file size etc. It's just that the file will not be downloaded. | 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
| *ignoreFileNotFoundOr PermissionError* (consumer) | Whether to ignore when trying to download a file which does not exist or due to permission error. By default when a file does not exists or insufficient permission then an exception is thrown. Setting this option to true allows to ignore that instead. | false | boolean
| *inProgressRepository* (consumer) | A pluggable in-progress repository org.apache.camel.spi.IdempotentRepository. The in-progress repository is used to account the current in progress files being consumed. By default a memory based repository is used. |  | String>
| *localWorkDirectory* (consumer) | When consuming a local work directory can be used to store the remote file content directly in local files to avoid loading the content into memory. This is beneficial if you consume a very big remote file and thus can conserve memory. |  | String
| *onCompletionException Handler* (consumer) | To use a custom org.apache.camel.spi.ExceptionHandler to handle any thrown exceptions that happens during the file on completion process where the consumer does either a commit or rollback. The default implementation will log any exception at WARN level and ignore. |  | ExceptionHandler
| *pollStrategy* (consumer) | A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. |  | PollingConsumerPoll Strategy
| *processStrategy* (consumer) | A pluggable org.apache.camel.component.file.GenericFileProcessStrategy allowing you to implement your own readLock option or similar. Can also be used when special conditions must be met before a file can be consumed such as a special ready file exists. If this option is set then the readLock option does not apply. |  | GenericFileProcess Strategy<T>
| *receiveBufferSize* (consumer) | The receive (download) buffer size Used only by FTPClient | 32768 | int
| *startingDirectoryMustExist* (consumer) | Whether the starting directory must exist. Mind that the autoCreate option is default enabled which means the starting directory is normally auto created if it doesn't exist. You can disable autoCreate and enable this to ensure the starting directory must exist. Will thrown an exception if the directory doesn't exist. | false | boolean
| *useList* (consumer) | Whether to allow using LIST command when downloading a file. Default is true. In some use cases you may want to download a specific file and are not allowed to use the LIST command and therefore you can set this option to false. | true | boolean
| *fileExist* (producer) | What to do if a file already exists with the same name. Override which is the default replaces the existing file. Append - adds content to the existing file. Fail - throws a GenericFileOperationException indicating that there is already an existing file. Ignore - silently ignores the problem and does not override the existing file but assumes everything is okay. Move - option requires to use the moveExisting option to be configured as well. The option eagerDeleteTargetFile can be used to control what to do if an moving the file and there exists already an existing file otherwise causing the move operation to fail. The Move option will move any existing files before writing the target file. TryRename Camel is only applicable if tempFileName option is in use. This allows to try renaming the file from the temporary name to the actual name without doing any exists check.This check may be faster on some file systems and especially FTP servers. | Override | GenericFileExist
| *flatten* (producer) | Flatten is used to flatten the file name path to strip any leading paths so it's just the file name. This allows you to consume recursively into sub-directories but when you eg write the files to another directory they will be written in a single directory. Setting this to true on the producer enforces that any file name in CamelFileName header will be stripped for any leading paths. | false | boolean
| *moveExisting* (producer) | Expression (such as File Language) used to compute file name to use when fileExist=Move is configured. To move files into a backup subdirectory just enter backup. This option only supports the following File Language tokens: file:name file:name.ext file:name.noext file:onlyname file:onlyname.noext file:ext and file:parent. Notice the file:parent is not supported by the FTP component as the FTP component can only move any existing files to a relative directory based on current dir as base. |  | String
| *tempFileName* (producer) | The same as tempPrefix option but offering a more fine grained control on the naming of the temporary filename as it uses the File Language. |  | String
| *tempPrefix* (producer) | This option is used to write the file using a temporary name and then after the write is complete rename it to the real name. Can be used to identify files being written and also avoid consumers (not using exclusive read locks) reading in progress files. Is often used by FTP when uploading big files. |  | String
| *allowNullBody* (producer) | Used to specify if a null body is allowed during file writing. If set to true then an empty file will be created when set to false and attempting to send a null body to the file component a GenericFileWriteException of 'Cannot write null body to file.' will be thrown. If the fileExist option is set to 'Override' then the file will be truncated and if set to append the file will remain unchanged. | false | boolean
| *chmod* (producer) | Allows you to set chmod on the stored file. For example chmod=640. |  | String
| *disconnectOnBatchComplete* (producer) | Whether or not to disconnect from remote FTP server right after a Batch upload is complete. disconnectOnBatchComplete will only disconnect the current connection to the FTP server. | false | boolean
| *eagerDeleteTargetFile* (producer) | Whether or not to eagerly delete any existing target file. This option only applies when you use fileExists=Override and the tempFileName option as well. You can use this to disable (set it to false) deleting the target file before the temp file is written. For example you may write big files and want the target file to exists during the temp file is being written. This ensure the target file is only deleted until the very last moment just before the temp file is being renamed to the target filename. This option is also used to control whether to delete any existing files when fileExist=Move is enabled and an existing file exists. If this option copyAndDeleteOnRenameFails false then an exception will be thrown if an existing file existed if its true then the existing file is deleted before the move operation. | true | boolean
| *keepLastModified* (producer) | Will keep the last modified timestamp from the source file (if any). Will use the Exchange.FILE_LAST_MODIFIED header to located the timestamp. This header can contain either a java.util.Date or long with the timestamp. If the timestamp exists and the option is enabled it will set this timestamp on the written file. Note: This option only applies to the file producer. You cannot use this option with any of the ftp producers. | false | boolean
| *sendNoop* (producer) | Whether to send a noop command as a pre-write check before uploading files to the FTP server. This is enabled by default as a validation of the connection is still valid which allows to silently re-connect to be able to upload the file. However if this causes problems you can turn this option off. | true | boolean
| *activePortRange* (advanced) | Set the client side port range in active mode. The syntax is: minPort-maxPort Both port numbers are inclusive eg 10000-19999 to include all 1xxxx ports. |  | String
| *autoCreate* (advanced) | Automatically create missing directories in the file's pathname. For the file consumer that means creating the starting directory. For the file producer it means the directory the files should be written to. | true | boolean
| *bufferSize* (advanced) | Write buffer sized in bytes. | 131072 | int
| *connectTimeout* (advanced) | Sets the connect timeout for waiting for a connection to be established Used by both FTPClient and JSCH | 10000 | int
| *ftpClient* (advanced) | To use a custom instance of FTPClient |  | FTPClient
| *ftpClientConfig* (advanced) | To use a custom instance of FTPClientConfig to configure the FTP client the endpoint should use. |  | FTPClientConfig
| *ftpClientConfigParameters* (advanced) | Used by FtpComponent to provide additional parameters for the FTPClientConfig |  | Map
| *ftpClientParameters* (advanced) | Used by FtpComponent to provide additional parameters for the FTPClient |  | Map
| *maximumReconnectAttempts* (advanced) | Specifies the maximum reconnect attempts Camel performs when it tries to connect to the remote FTP server. Use 0 to disable this behavior. |  | int
| *reconnectDelay* (advanced) | Delay in millis Camel will wait before performing a reconnect attempt. |  | long
| *siteCommand* (advanced) | Sets optional site command(s) to be executed after successful login. Multiple site commands can be separated using a new line character (\\n). |  | String
| *soTimeout* (advanced) | Sets the so timeout Used only by FTPClient | 300000 | int
| *stepwise* (advanced) | Sets whether we should stepwise change directories while traversing file structures when downloading files or as well when uploading a file to a directory. You can disable this if you for example are in a situation where you cannot change directory on the FTP server due security reasons. | true | boolean
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *throwExceptionOnConnect Failed* (advanced) | Should an exception be thrown if connection failed (exhausted) By default exception is not thrown and a WARN is logged. You can use this to enable exception being thrown and handle the thrown exception from the org.apache.camel.spi.PollingConsumerPollStrategy rollback method. | false | boolean
| *timeout* (advanced) | Sets the data timeout for waiting for reply Used only by FTPClient | 30000 | int
| *antExclude* (filter) | Ant style filter exclusion. If both antInclude and antExclude are used antExclude takes precedence over antInclude. Multiple exclusions may be specified in comma-delimited format. |  | String
| *antFilterCaseSensitive* (filter) | Sets case sensitive flag on ant fiter | true | boolean
| *antInclude* (filter) | Ant style filter inclusion. Multiple inclusions may be specified in comma-delimited format. |  | String
| *eagerMaxMessagesPerPoll* (filter) | Allows for controlling whether the limit from maxMessagesPerPoll is eager or not. If eager then the limit is during the scanning of files. Where as false would scan all files and then perform sorting. Setting this option to false allows for sorting all files first and then limit the poll. Mind that this requires a higher memory usage as all file details are in memory to perform the sorting. | true | boolean
| *exclude* (filter) | Is used to exclude files if filename matches the regex pattern (matching is case in-senstive). Notice if you use symbols such as plus sign and others you would need to configure this using the RAW() syntax if configuring this as an endpoint uri. See more details at configuring endpoint uris |  | String
| *filter* (filter) | Pluggable filter as a org.apache.camel.component.file.GenericFileFilter class. Will skip files if filter returns false in its accept() method. |  | GenericFileFilter<T>
| *filterDirectory* (filter) | Filters the directory based on Simple language. For example to filter on current date you can use a simple date pattern such as $date:now:yyyMMdd |  | String
| *filterFile* (filter) | Filters the file based on Simple language. For example to filter on file size you can use $file:size 5000 |  | String
| *idempotent* (filter) | Option to use the Idempotent Consumer EIP pattern to let Camel skip already processed files. Will by default use a memory based LRUCache that holds 1000 entries. If noop=true then idempotent will be enabled as well to avoid consuming the same files over and over again. | false | Boolean
| *idempotentKey* (filter) | To use a custom idempotent key. By default the absolute path of the file is used. You can use the File Language for example to use the file name and file size you can do: idempotentKey=$file:name-$file:size |  | String
| *idempotentRepository* (filter) | A pluggable repository org.apache.camel.spi.IdempotentRepository which by default use MemoryMessageIdRepository if none is specified and idempotent is true. |  | String>
| *include* (filter) | Is used to include files if filename matches the regex pattern (matching is case in-sensitive). Notice if you use symbols such as plus sign and others you would need to configure this using the RAW() syntax if configuring this as an endpoint uri. See more details at configuring endpoint uris |  | String
| *maxDepth* (filter) | The maximum depth to traverse when recursively processing a directory. | 2147483647 | int
| *maxMessagesPerPoll* (filter) | To define a maximum messages to gather per poll. By default no maximum is set. Can be used to set a limit of e.g. 1000 to avoid when starting up the server that there are thousands of files. Set a value of 0 or negative to disabled it. Notice: If this option is in use then the File and FTP components will limit before any sorting. For example if you have 100000 files and use maxMessagesPerPoll=500 then only the first 500 files will be picked up and then sorted. You can use the eagerMaxMessagesPerPoll option and set this to false to allow to scan all files first and then sort afterwards. |  | int
| *minDepth* (filter) | The minimum depth to start processing when recursively processing a directory. Using minDepth=1 means the base directory. Using minDepth=2 means the first sub directory. |  | int
| *move* (filter) | Expression (such as Simple Language) used to dynamically set the filename when moving it after processing. To move files into a .done subdirectory just enter .done. |  | String
| *exclusiveReadLockStrategy* (lock) | Pluggable read-lock as a org.apache.camel.component.file.GenericFileExclusiveReadLockStrategy implementation. |  | GenericFileExclusive ReadLockStrategy<T>
| *readLock* (lock) | Used by consumer to only poll the files if it has exclusive read-lock on the file (i.e. the file is not in-progress or being written). Camel will wait until the file lock is granted. This option provides the build in strategies: none - No read lock is in use markerFile - Camel creates a marker file (fileName.camelLock) and then holds a lock on it. This option is not available for the FTP component changed - Changed is using file length/modification timestamp to detect whether the file is currently being copied or not. Will at least use 1 sec to determine this so this option cannot consume files as fast as the others but can be more reliable as the JDK IO API cannot always determine whether a file is currently being used by another process. The option readLockCheckInterval can be used to set the check frequency. fileLock - is for using java.nio.channels.FileLock. This option is not avail for the FTP component. This approach should be avoided when accessing a remote file system via a mount/share unless that file system supports distributed file locks. rename - rename is for using a try to rename the file as a test if we can get exclusive read-lock. idempotent - (only for file component) idempotent is for using a idempotentRepository as the read-lock. This allows to use read locks that supports clustering if the idempotent repository implementation supports that. idempotent-changed - (only for file component) idempotent-changed is for using a idempotentRepository and changed as the combined read-lock. This allows to use read locks that supports clustering if the idempotent repository implementation supports that. idempotent-rename - (only for file component) idempotent-rename is for using a idempotentRepository and rename as the combined read-lock. This allows to use read locks that supports clustering if the idempotent repository implementation supports that. Notice: The various read locks is not all suited to work in clustered mode where concurrent consumers on different nodes is competing for the same files on a shared file system. The markerFile using a close to atomic operation to create the empty marker file but its not guaranteed to work in a cluster. The fileLock may work better but then the file system need to support distributed file locks and so on. Using the idempotent read lock can support clustering if the idempotent repository supports clustering such as Hazelcast Component or Infinispan. |  | String
| *readLockCheckInterval* (lock) | Interval in millis for the read-lock if supported by the read lock. This interval is used for sleeping between attempts to acquire the read lock. For example when using the changed read lock you can set a higher interval period to cater for slow writes. The default of 1 sec. may be too fast if the producer is very slow writing the file. Notice: For FTP the default readLockCheckInterval is 5000. The readLockTimeout value must be higher than readLockCheckInterval but a rule of thumb is to have a timeout that is at least 2 or more times higher than the readLockCheckInterval. This is needed to ensure that amble time is allowed for the read lock process to try to grab the lock before the timeout was hit. | 1000 | long
| *readLockDeleteOrphanLock Files* (lock) | Whether or not read lock with marker files should upon startup delete any orphan read lock files which may have been left on the file system if Camel was not properly shutdown (such as a JVM crash). If turning this option to false then any orphaned lock file will cause Camel to not attempt to pickup that file this could also be due another node is concurrently reading files from the same shared directory. | true | boolean
| *readLockLoggingLevel* (lock) | Logging level used when a read lock could not be acquired. By default a WARN is logged. You can change this level for example to OFF to not have any logging. This option is only applicable for readLock of types: changed fileLock idempotent idempotent-changed idempotent-rename rename. | DEBUG | LoggingLevel
| *readLockMarkerFile* (lock) | Whether to use marker file with the changed rename or exclusive read lock types. By default a marker file is used as well to guard against other processes picking up the same files. This behavior can be turned off by setting this option to false. For example if you do not want to write marker files to the file systems by the Camel application. | true | boolean
| *readLockMinAge* (lock) | This option applied only for readLock=change. This option allows to specify a minimum age the file must be before attempting to acquire the read lock. For example use readLockMinAge=300s to require the file is at last 5 minutes old. This can speedup the changed read lock as it will only attempt to acquire files which are at least that given age. | 0 | long
| *readLockMinLength* (lock) | This option applied only for readLock=changed. This option allows you to configure a minimum file length. By default Camel expects the file to contain data and thus the default value is 1. You can set this option to zero to allow consuming zero-length files. | 1 | long
| *readLockRemoveOnCommit* (lock) | This option applied only for readLock=idempotent. This option allows to specify whether to remove the file name entry from the idempotent repository when processing the file is succeeded and a commit happens. By default the file is not removed which ensures that any race-condition do not occur so another active node may attempt to grab the file. Instead the idempotent repository may support eviction strategies that you can configure to evict the file name entry after X minutes - this ensures no problems with race conditions. | false | boolean
| *readLockRemoveOnRollback* (lock) | This option applied only for readLock=idempotent. This option allows to specify whether to remove the file name entry from the idempotent repository when processing the file failed and a rollback happens. If this option is false then the file name entry is confirmed (as if the file did a commit). | true | boolean
| *readLockTimeout* (lock) | Optional timeout in millis for the read-lock if supported by the read-lock. If the read-lock could not be granted and the timeout triggered then Camel will skip the file. At next poll Camel will try the file again and this time maybe the read-lock could be granted. Use a value of 0 or lower to indicate forever. Currently fileLock changed and rename support the timeout. Notice: For FTP the default readLockTimeout value is 20000 instead of 10000. The readLockTimeout value must be higher than readLockCheckInterval but a rule of thumb is to have a timeout that is at least 2 or more times higher than the readLockCheckInterval. This is needed to ensure that amble time is allowed for the read lock process to try to grab the lock before the timeout was hit. | 10000 | long
| *backoffErrorThreshold* (scheduler) | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in. |  | int
| *backoffIdleThreshold* (scheduler) | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in. |  | int
| *backoffMultiplier* (scheduler) | To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured. |  | int
| *delay* (scheduler) | Milliseconds before the next poll. You can also specify time values using units such as 60s (60 seconds) 5m30s (5 minutes and 30 seconds) and 1h (1 hour). | 500 | long
| *greedy* (scheduler) | If greedy is enabled then the ScheduledPollConsumer will run immediately again if the previous run polled 1 or more messages. | false | boolean
| *initialDelay* (scheduler) | Milliseconds before the first poll starts. You can also specify time values using units such as 60s (60 seconds) 5m30s (5 minutes and 30 seconds) and 1h (1 hour). | 1000 | long
| *runLoggingLevel* (scheduler) | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. | TRACE | LoggingLevel
| *scheduledExecutorService* (scheduler) | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool. |  | ScheduledExecutor Service
| *scheduler* (scheduler) | To use a cron scheduler from either camel-spring or camel-quartz2 component | none | ScheduledPollConsumer Scheduler
| *schedulerProperties* (scheduler) | To configure additional properties when using a custom scheduler or any of the Quartz2 Spring based scheduler. |  | Map
| *startScheduler* (scheduler) | Whether the scheduler should be auto started. | true | boolean
| *timeUnit* (scheduler) | Time unit for initialDelay and delay options. | MILLISECONDS | TimeUnit
| *useFixedDelay* (scheduler) | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. | true | boolean
| *shuffle* (sort) | To shuffle the list of files (sort in random order) | false | boolean
| *sortBy* (sort) | Built-in sort by using the File Language. Supports nested sorts so you can have a sort by file name and as a 2nd group sort by modified date. |  | String
| *sorter* (sort) | Pluggable sorter as a java.util.Comparator class. |  | GenericFile<T>>
| *account* (security) | Account to use for login |  | String
| *password* (security) | Password to use for login |  | String
| *username* (security) | Username to use for login |  | String
|===
// endpoint options: END



### FTPS component default trust store

When using the `ftpClient.` properties related to SSL with the FTPS
component, the trust store accept all certificates. If you only want
trust selective certificates, you have to configure the trust store with
the `ftpClient.trustStore.xxx` options or by configuring a custom
`ftpClient`.

When using `sslContextParameters`, the trust store is managed by the
configuration of the provided SSLContextParameters instance.

You can configure additional options on the `ftpClient` and
`ftpClientConfig` from the URI directly by using the `ftpClient.` or
`ftpClientConfig.` prefix.

For example to set the `setDataTimeout` on the `FTPClient` to 30 seconds
you can do:

[source,java]
--------------------------------------------------------------------------------------
from(""ftp://foo@myserver?password=secret&ftpClient.dataTimeout=30000"").to(""bean:foo"");
--------------------------------------------------------------------------------------

You can mix and match and have use both prefixes, for example to
configure date format or timezones.

[source,java]
----------------------------------------------------------------------------------------------------------------------------
from(""ftp://foo@myserver?password=secret&ftpClient.dataTimeout=30000&ftpClientConfig.serverLanguageCode=fr"").to(""bean:foo"");
----------------------------------------------------------------------------------------------------------------------------

You can have as many of these options as you like.

See the documentation of the Apache Commons FTP FTPClientConfig for
possible options and more details. And as well for Apache Commons FTP
FTPClient.

If you do not like having many and long configuration in the url you can
refer to the `ftpClient` or `ftpClientConfig` to use by letting Camel
lookup in the link:registry.html[Registry] for it.

For example:

[source,java]
--------------------------------------------------------------------------
   <bean id=""myConfig"" class=""org.apache.commons.net.ftp.FTPClientConfig"">
       <property name=""lenientFutureDates"" value=""true""/>
       <property name=""serverLanguageCode"" value=""fr""/>
   </bean>
--------------------------------------------------------------------------

And then let Camel lookup this bean when you use the # notation in the
url.

[source,java]
------------------------------------------------------------------------------------
from(""ftp://foo@myserver?password=secret&ftpClientConfig=#myConfig"").to(""bean:foo"");
------------------------------------------------------------------------------------

### More URI options


### Examples

`ftp://someone@someftpserver.com/public/upload/images/holiday2008?password=secret&binary=true` +

`ftp://someoneelse@someotherftpserver.co.uk:12049/reports/2008/password=secret&binary=false` +
 `ftp://publicftpserver.com/download`

### Concurrency

FTP Consumer does not support concurrency

The FTP consumer (with the same endpoint) does not support concurrency
(the backing FTP client is not thread safe). +
 You can use multiple FTP consumers to poll from different endpoints. It
is only a single endpoint that does not support concurrent consumers.

The FTP producer does *not* have this issue, it supports concurrency.

### More information

This component is an extension of the link:file2.html[File] component.
So there are more samples and details on the link:file2.html[File]
component page.

====

### Default when consuming files

The link:ftp2.html[FTP] consumer will by default leave the consumed
files untouched on the remote FTP server. You have to configure it
explicitly if you want it to delete the files or move them to another
location. For example you can use `delete=true` to delete the files, or
use `move=.done` to move the files into a hidden done sub directory.

The regular link:file2.html[File] consumer is different as it will by
default move files to a `.camel` sub directory. The reason Camel does
*not* do this by default for the FTP consumer is that it may lack
permissions by default to be able to move or delete files.

#### limitations

The option *readLock* can be used to force Camel *not* to consume files
that is currently in the progress of being written. However, this option
is turned off by default, as it requires that the user has write access.
See the options table at link:file2.html[File2] for more details about
read locks. +
 There are other solutions to avoid consuming files that are currently
being written over FTP; for instance, you can write to a temporary
destination and move the file after it has been written.

When moving files using `move` or `preMove` option the files are
restricted to the FTP_ROOT folder. That prevents you from moving files
outside the FTP area. If you want to move files to another area you can
use soft links and move files into a soft linked folder.

### Message Headers

The following message headers can be used to affect the behavior of the
component

[width=""100%"",cols=""50%,50%"",options=""header"",]
|=======================================================================
|Header |Description

|`CamelFileName` |Specifies the output file name (relative to the endpoint directory) to
be used for the output message when sending to the endpoint. If this is
not present and no expression either, then a generated message ID is
used as the filename instead.

|`CamelFileNameProduced` |The actual filepath (path + name) for the output file that was written.
This header is set by Camel and its purpose is providing end-users the
name of the file that was written.

|`CamelFileIndex` |Current index out of total number of files being consumed in this batch.

|`CamelFileSize` |Total number of files being consumed in this batch.

|`CamelFileHost` |The remote hostname.

|`CamelFileLocalWorkPath` |Path to the local work file, if local work directory is used.
|=======================================================================

In addition the FTP/FTPS consumer and producer will enrich the Camel
`Message` with the following headers

[width=""100%"",cols=""50%,50%"",options=""header"",]
|=======================================================================
|Header |Description

|`CamelFtpReplyCode` |*Camel 2.11.1:* The FTP client reply code (the type is a integer)

|`CamelFtpReplyString` | *Camel 2.11.1:* The FTP client reply string
|=======================================================================

### About timeouts

The two set of libraries (see top) has different API for setting
timeout. You can use the `connectTimeout` option for both of them to set
a timeout in millis to establish a network connection. An individual
`soTimeout` can also be set on the FTP/FTPS, which corresponds to using
`ftpClient.soTimeout`. Notice SFTP will automatically use
`connectTimeout` as its `soTimeout`. The `timeout` option only applies
for FTP/FTSP as the data timeout, which corresponds to the
`ftpClient.dataTimeout` value. All timeout values are in millis.

### Using Local Work Directory

Camel supports consuming from remote FTP servers and downloading the
files directly into a local work directory. This avoids reading the
entire remote file content into memory as it is streamed directly into
the local file using `FileOutputStream`.

Camel will store to a local file with the same name as the remote file,
though with `.inprogress` as extension while the file is being
downloaded. Afterwards, the file is renamed to remove the `.inprogress`
suffix. And finally, when the link:exchange.html[Exchange] is complete
the local file is deleted.

So if you want to download files from a remote FTP server and store it
as files then you need to route to a file endpoint such as:

[source,java]
------------------------------------------------------------------------------------------------
from(""ftp://someone@someserver.com?password=secret&localWorkDirectory=/tmp"").to(""file://inbox"");
------------------------------------------------------------------------------------------------

[Tip]
====
 *Optimization by renaming work file*

The route above is ultra efficient as it avoids reading the entire file
content into memory. It will download the remote file directly to a
local file stream. The `java.io.File` handle is then used as the
link:exchange.html[Exchange] body. The file producer leverages this fact
and can work directly on the work file `java.io.File` handle and perform
a `java.io.File.rename` to the target filename. As Camel knows it's a
local work file, it can optimize and use a rename instead of a file
copy, as the work file is meant to be deleted anyway.

====

### Stepwise changing directories

Camel link:ftp2.html[FTP] can operate in two modes in terms of
traversing directories when consuming files (eg downloading) or
producing files (eg uploading)

* stepwise
* not stepwise

You may want to pick either one depending on your situation and security
issues. Some Camel end users can only download files if they use
stepwise, while others can only download if they do not. At least you
have the choice to pick (from Camel 2.6 onwards).

In Camel 2.0 - 2.5 there is only one mode and it is:

* before 2.5 not stepwise
* 2.5 stepwise

From Camel 2.6 onwards there is now an option `stepwise` you can use to
control the behavior.

Note that stepwise changing of directory will in most cases only work
when the user is confined to it's home directory and when the home
directory is reported as `""/""`.

The difference between the two of them is best illustrated with an
example. Suppose we have the following directory structure on the remote
FTP server we need to traverse and download files:

[source,java]
--------------
/
/one
/one/two
/one/two/sub-a
/one/two/sub-b
--------------

And that we have a file in each of sub-a (a.txt) and sub-b (b.txt)
folder.

#### Using stepwise=true (default mode)

[source,java]
----------------------------------------------------------
TYPE A
200 Type set to A
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
SYST
215 UNIX emulated by FileZilla
PORT 127,0,0,1,17,94
200 Port command successful
LIST
150 Opening data channel for directory list.
226 Transfer OK
CWD sub-a
250 CWD successful. ""/one/two/sub-a"" is current directory.
PORT 127,0,0,1,17,95
200 Port command successful
LIST
150 Opening data channel for directory list.
226 Transfer OK
CDUP
200 CDUP successful. ""/one/two"" is current directory.
CWD sub-b
250 CWD successful. ""/one/two/sub-b"" is current directory.
PORT 127,0,0,1,17,96
200 Port command successful
LIST
150 Opening data channel for directory list.
226 Transfer OK
CDUP
200 CDUP successful. ""/one/two"" is current directory.
CWD /
250 CWD successful. ""/"" is current directory.
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
PORT 127,0,0,1,17,97
200 Port command successful
RETR foo.txt
150 Opening data channel for file transfer.
226 Transfer OK
CWD /
250 CWD successful. ""/"" is current directory.
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
CWD sub-a
250 CWD successful. ""/one/two/sub-a"" is current directory.
PORT 127,0,0,1,17,98
200 Port command successful
RETR a.txt
150 Opening data channel for file transfer.
226 Transfer OK
CWD /
250 CWD successful. ""/"" is current directory.
PWD
257 ""/"" is current directory.
CWD one
250 CWD successful. ""/one"" is current directory.
CWD two
250 CWD successful. ""/one/two"" is current directory.
CWD sub-b
250 CWD successful. ""/one/two/sub-b"" is current directory.
PORT 127,0,0,1,17,99
200 Port command successful
RETR b.txt
150 Opening data channel for file transfer.
226 Transfer OK
CWD /
250 CWD successful. ""/"" is current directory.
QUIT
221 Goodbye
disconnected.
----------------------------------------------------------

As you can see when stepwise is enabled, it will traverse the directory
structure using CD xxx.

#### Using stepwise=false

[source,java]
-------------------------------------------
230 Logged on
TYPE A
200 Type set to A
SYST
215 UNIX emulated by FileZilla
PORT 127,0,0,1,4,122
200 Port command successful
LIST one/two
150 Opening data channel for directory list
226 Transfer OK
PORT 127,0,0,1,4,123
200 Port command successful
LIST one/two/sub-a
150 Opening data channel for directory list
226 Transfer OK
PORT 127,0,0,1,4,124
200 Port command successful
LIST one/two/sub-b
150 Opening data channel for directory list
226 Transfer OK
PORT 127,0,0,1,4,125
200 Port command successful
RETR one/two/foo.txt
150 Opening data channel for file transfer.
226 Transfer OK
PORT 127,0,0,1,4,126
200 Port command successful
RETR one/two/sub-a/a.txt
150 Opening data channel for file transfer.
226 Transfer OK
PORT 127,0,0,1,4,127
200 Port command successful
RETR one/two/sub-b/b.txt
150 Opening data channel for file transfer.
226 Transfer OK
QUIT
221 Goodbye
disconnected.
-------------------------------------------

As you can see when not using stepwise, there are no CD operation
invoked at all.

### Samples

In the sample below we set up Camel to download all the reports from the
FTP server once every hour (60 min) as BINARY content and store it as
files on the local file system.

And the route using Spring DSL:

[source,xml]
------------------------------------------------------------------------------------------------------
  <route>
     <from uri=""ftp://scott@localhost/public/reports?password=tiger&amp;binary=true&amp;delay=60000""/>
     <to uri=""file://target/test-reports""/>
  </route>
------------------------------------------------------------------------------------------------------

#### Consuming a remote FTPS server (implicit SSL) and client authentication

[source,java]
--------------------------------------------------------------------------------------------------
from(""ftps://admin@localhost:2222/public/camel?password=admin&securityProtocol=SSL&isImplicit=true
      &ftpClient.keyStore.file=./src/test/resources/server.jks
      &ftpClient.keyStore.password=password&ftpClient.keyStore.keyPassword=password"")
  .to(""bean:foo"");
--------------------------------------------------------------------------------------------------

#### Consuming a remote FTPS server (explicit TLS) and a custom trust store configuration

[source,java]
----------------------------------------------------------------------------------------------------------------------------------------------------------------
from(""ftps://admin@localhost:2222/public/camel?password=admin&ftpClient.trustStore.file=./src/test/resources/server.jks&ftpClient.trustStore.password=password"")
  .to(""bean:foo"");
----------------------------------------------------------------------------------------------------------------------------------------------------------------

### Filter using `org.apache.camel.component.file.GenericFileFilter`

Camel supports pluggable filtering strategies. This strategy it to use
the build in `org.apache.camel.component.file.GenericFileFilter` in
Java. You can then configure the endpoint with such a filter to skip
certain filters before being processed.

In the sample we have built our own filter that only accepts files
starting with report in the filename.

And then we can configure our route using the *filter* attribute to
reference our filter (using `#` notation) that we have defined in the
spring XML file:

[source,xml]
---------------------------------------------------------------------------------------
   <!-- define our sorter as a plain spring bean -->
   <bean id=""myFilter"" class=""com.mycompany.MyFileFilter""/>

  <route>
    <from uri=""ftp://someuser@someftpserver.com?password=secret&amp;filter=#myFilter""/>
    <to uri=""bean:processInbox""/>
  </route>
---------------------------------------------------------------------------------------

### Filtering using ANT path matcher

The ANT path matcher is a filter that is shipped out-of-the-box in the
*camel-spring* jar. So you need to depend on *camel-spring* if you are
using Maven. +
 The reason is that we leverage Spring's
http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/util/AntPathMatcher.html[AntPathMatcher]
to do the actual matching.

The file paths are matched with the following rules:

* `?` matches one character
* `*` matches zero or more characters
* `**` matches zero or more directories in a path

The sample below demonstrates how to use it:

### Using a proxy with SFTP

To use an HTTP proxy to connect to your remote host, you can configure
your route in the following way:

[source,xml]
-------------------------------------------------------------------------------------
<!-- define our sorter as a plain spring bean -->
<bean id=""proxy"" class=""com.jcraft.jsch.ProxyHTTP"">
  <constructor-arg value=""localhost""/>
  <constructor-arg value=""7777""/>
</bean>

<route>
  <from uri=""sftp://localhost:9999/root?username=admin&password=admin&proxy=#proxy""/>
  <to uri=""bean:processFile""/>
</route>
-------------------------------------------------------------------------------------

You can also assign a user name and password to the proxy, if necessary.
Please consult the documentation for `com.jcraft.jsch.Proxy` to discover
all options.

### Setting preferred SFTP authentication method

If you want to explicitly specify the list of authentication methods
that should be used by `sftp` component, use `preferredAuthentications`
option. If for example you would like Camel to attempt to authenticate
with private/public SSH key and fallback to user/password authentication
in the case when no public key is available, use the following route
configuration:

[source,java]
-------------------------------------------------------------------------------------------------------------
from(""sftp://localhost:9999/root?username=admin&password=admin&preferredAuthentications=publickey,password"").
  to(""bean:processFile"");
-------------------------------------------------------------------------------------------------------------

### Consuming a single file using a fixed name

When you want to download a single file and knows the file name, you can
use `fileName=myFileName.txt` to tell Camel the name of the file to
download. By default the consumer will still do a FTP LIST command to do
a directory listing and then filter these files based on the `fileName`
option. Though in this use-case it may be desirable to turn off the
directory listing by setting `useList=false`. For example the user
account used to login to the FTP server may not have permission to do a
FTP LIST command. So you can turn off this with `useList=false`, and
then provide the fixed name of the file to download with
`fileName=myFileName.txt`, then the FTP consumer can still download the
file. If the file for some reason does not exist, then Camel will by
default throw an exception, you can turn this off and ignore this by
setting `ignoreFileNotFoundOrPermissionError=true`.

For example to have a Camel route that pickup a single file, and delete
it after use you can do

[source,java]
-------------------------------------------------------------------------------------------------------------------------------------------------------------
from(""ftp://admin@localhost:21/nolist/?password=admin&stepwise=false&useList=false&ignoreFileNotFoundOrPermissionError=true&fileName=report.txt&delete=true"")
  .to(""activemq:queue:report"");
-------------------------------------------------------------------------------------------------------------------------------------------------------------

Notice that we have use all the options we talked above above.

You can also use this with `ConsumerTemplate`. For example to download a
single file (if it exists) and grab the file content as a String type:

[source,java]
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
String data = template.retrieveBodyNoWait(""ftp://admin@localhost:21/nolist/?password=admin&stepwise=false&useList=false&ignoreFileNotFoundOrPermissionError=true&fileName=report.txt&delete=true"", String.class);
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

### Debug logging

This component has log level *TRACE* that can be helpful if you have
problems.

### See Also

* link:configuring-camel.html[Configuring Camel]
* link:component.html[Component]
* link:endpoint.html[Endpoint]
* link:getting-started.html[Getting Started]

* link:file2.html[File2]
",12232,False,2048.221681092783,median
"CLASS ltcl_syntax_cases DEFINITION DEFERRED.
CLASS zcl_abapgit_syntax_highlighter DEFINITION LOCAL FRIENDS ltcl_syntax_cases.

*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_cases definition
*----------------------------------------------------------------------*
CLASS ltcl_syntax_cases DEFINITION FINAL FOR TESTING RISK LEVEL HARMLESS
    DURATION SHORT.

  PRIVATE SECTION.

    DATA:
      mt_after_parse  TYPE zcl_abapgit_syntax_highlighter=>ty_match_tt,
      mt_after_order  TYPE zcl_abapgit_syntax_highlighter=>ty_match_tt,
      mt_after_extend TYPE zcl_abapgit_syntax_highlighter=>ty_match_tt.

    METHODS:
      do_test IMPORTING iv_line     TYPE string
                        iv_filename TYPE string,
      generate_parse IMPORTING iv_token  TYPE char01
                               iv_offset TYPE i
                               iv_length TYPE i,
      generate_order IMPORTING iv_token    TYPE char01
                               iv_offset   TYPE i
                               iv_length   TYPE i
                               iv_text_tag TYPE string,
      generate_extend IMPORTING iv_token    TYPE char01
                                iv_offset   TYPE i
                                iv_length   TYPE i
                                iv_text_tag TYPE string,
      test_abap_01 FOR TESTING,
      test_abap_02 FOR TESTING,
      test_abap_03 FOR TESTING,
      test_abap_04 FOR TESTING,
      test_abap_05 FOR TESTING,
      test_abap_06 FOR TESTING,
      test_abap_07 FOR TESTING,
      test_abap_08 FOR TESTING,
      test_xml_01  FOR TESTING,
      test_xml_02  FOR TESTING,
      test_xml_03  FOR TESTING,
      test_xml_04  FOR TESTING,
      test_xml_05  FOR TESTING,
      test_xml_06  FOR TESTING,
      test_xml_07  FOR TESTING,
      test_xml_08  FOR TESTING.

ENDCLASS.
*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_cases IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS ltcl_syntax_cases IMPLEMENTATION.

  METHOD do_test.

    DATA: lt_matches_act TYPE zcl_abapgit_syntax_highlighter=>ty_match_tt,
          lo_syntax      TYPE REF TO zcl_abapgit_syntax_highlighter.


    lo_syntax = zcl_abapgit_syntax_highlighter=>create( iv_filename ).
    lt_matches_act = lo_syntax->parse_line( iv_line ).

    SORT lt_matches_act BY offset.

    cl_abap_unit_assert=>assert_equals( exp = mt_after_parse
                                        act = lt_matches_act
                                        msg = | Error during parsing: { iv_line }| ).

    lo_syntax->order_matches( EXPORTING iv_line    = iv_line
                       CHANGING  ct_matches = lt_matches_act ).

    cl_abap_unit_assert=>assert_equals( exp = mt_after_order
                                        act = lt_matches_act
                                        msg = | Error during ordering: { iv_line }| ).

    lo_syntax->extend_matches(
      EXPORTING
        iv_line    = iv_line
      CHANGING
        ct_matches = lt_matches_act ).

    cl_abap_unit_assert=>assert_equals( exp = mt_after_extend
                                        act = lt_matches_act
                                        msg = | Error during extending: { iv_line }| ).

  ENDMETHOD.

  METHOD generate_parse.
    DATA ls_match TYPE zcl_abapgit_syntax_highlighter=>ty_match.

    ls_match-token    = iv_token.
    ls_match-offset   = iv_offset.
    ls_match-length   = iv_length.
    APPEND ls_match TO mt_after_parse.
  ENDMETHOD.

  METHOD generate_order.
    DATA ls_match TYPE zcl_abapgit_syntax_highlighter=>ty_match.

    ls_match-token    = iv_token.
    ls_match-offset   = iv_offset.
    ls_match-length   = iv_length.
    ls_match-text_tag = iv_text_tag.
    APPEND ls_match TO mt_after_order.
  ENDMETHOD.

  METHOD generate_extend.
    DATA ls_match TYPE zcl_abapgit_syntax_highlighter=>ty_match.

    ls_match-token    = iv_token.
    ls_match-offset   = iv_offset.
    ls_match-length   = iv_length.
    ls_match-text_tag = iv_text_tag.
    APPEND ls_match TO mt_after_extend.
  ENDMETHOD.

******************************************************
* Test parsing and ordering of comments              *
******************************************************
  METHOD test_abap_01.

    DATA lv_line TYPE string.

    lv_line = '* commented out line with key word data'.    ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'C'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 12
                    iv_length = 3 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 16
                    iv_length = 4 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 21
                    iv_length = 4 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 26
                    iv_length = 3 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 30
                    iv_length = 4 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 35
                    iv_length = 4 ).


    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'C'
                    iv_offset   = 0
                    iv_length   = 39
                    iv_text_tag = '' ).

    "" Generate table with expected values after ordering
    generate_extend( iv_token    = 'C'
                     iv_offset   = 0
                     iv_length   = 39
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of remainder of string   *
******************************************************
  METHOD test_abap_02.

    DATA lv_line TYPE string.

    lv_line = 'data: lv_var_name type string.'.             ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'K'
                    iv_offset = 0
                    iv_length = 4 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 18
                    iv_length = 4 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'K'
                    iv_offset   = 0
                    iv_length   = 4
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 18
                    iv_length   = 4
                    iv_text_tag = '' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'K'
                     iv_offset   = 0
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 4
                     iv_length   = 14
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 18
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 22
                     iv_length   = 8
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of key words & texts     *
******************************************************
  METHOD test_abap_03.

    DATA lv_line TYPE string.


    lv_line = 'call function ''FM_NAME''. "" Commented'.     ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'K'
                    iv_offset = 0
                    iv_length = 4 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 5
                    iv_length = 8 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 14
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 22
                    iv_length = 1 ).
    generate_parse( iv_token  = 'C'
                    iv_offset = 25
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'K'
                    iv_offset   = 0
                    iv_length   = 4
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 5
                    iv_length   = 8
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 14
                    iv_length   = 9
                    iv_text_tag = '''' ).
    generate_order( iv_token    = 'C'
                    iv_offset   = 25
                    iv_length   = 11
                    iv_text_tag = '' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'K'
                     iv_offset   = 0
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 4
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 5
                     iv_length   = 8
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 13
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 14
                     iv_length   = 9
                     iv_text_tag = '''' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 23
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'C'
                     iv_offset   = 25
                     iv_length   = 11
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of key words in texts    *
******************************************************
  METHOD test_abap_04.

    DATA lv_line TYPE string.

    lv_line = 'constants: lc_var type string value ''simpletext data simpletext''.'. ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'K'
                    iv_offset = 0
                    iv_length = 9 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 18
                    iv_length = 4 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 30
                    iv_length = 5 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 36
                    iv_length = 1 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 48
                    iv_length = 4 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 63
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'K'
                    iv_offset   = 0
                    iv_length   = 9
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 18
                    iv_length   = 4
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 30
                    iv_length   = 5
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 36
                    iv_length   = 28
                    iv_text_tag = '''' ).

    "" Generate table with expected values after ordering
    generate_extend( iv_token    = 'K'
                     iv_offset   = 0
                     iv_length   = 9
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 9
                     iv_length   = 9
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 18
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 22
                     iv_length   = 8
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 30
                     iv_length   = 5
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 35
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 36
                     iv_length   = 28
                     iv_text_tag = '''' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 64
                     iv_length   = 1
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering texts in curly brackets  *
******************************************************
  METHOD test_abap_05.

    DATA lv_line TYPE string.

    lv_line = 'a = |{ b }={ c }|.'.                         ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'T'
                    iv_offset = 4
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 5
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 9
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 11
                    iv_length = 1 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 13
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 15
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 16
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'T'
                    iv_offset   = 4
                    iv_length   = 1
                    iv_text_tag = '|' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 10
                    iv_length   = 1
                    iv_text_tag = '}' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 13
                    iv_length   = 1
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 16
                    iv_length   = 1
                    iv_text_tag = '}' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = '.'
                     iv_offset   = 0
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 4
                     iv_length   = 1
                     iv_text_tag = '|' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 5
                     iv_length   = 5
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 10
                     iv_length   = 1
                     iv_text_tag = '}' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 11
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 13
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 14
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 16
                     iv_length   = 1
                     iv_text_tag = '}' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 17
                     iv_length   = 1
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of texts                 *
******************************************************
  METHOD test_abap_06.

    DATA lv_line TYPE string.

    lv_line = 'lv_line = lc_constant && |XYZ { ''ab'' && |ac{ ''UU'' }| }|'. ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'K'
                    iv_offset = 22
                    iv_length = 2 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 25
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 30
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 32
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 35
                    iv_length = 1 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 37
                    iv_length = 2 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 40
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 43
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 45
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 48
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 50
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 51
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 53
                    iv_length = 1 ).
    generate_parse( iv_token  = 'T'
                    iv_offset = 54
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'K'
                    iv_offset   = 22
                    iv_length   = 2
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 25
                    iv_length   = 5
                    iv_text_tag = '|' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 32
                    iv_length   = 4
                    iv_text_tag = '''' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 37
                    iv_length   = 2
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 40
                    iv_length   = 3
                    iv_text_tag = '|' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 45
                    iv_length   = 4
                    iv_text_tag = '''' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 51
                    iv_length   = 1
                    iv_text_tag = '}' ).
    generate_order( iv_token    = 'T'
                    iv_offset   = 54
                    iv_length   = 1
                    iv_text_tag = '}' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = '.'
                     iv_offset   = 00
                     iv_length   = 22
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 22
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 24
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 25
                     iv_length   = 5
                     iv_text_tag = '|' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 30
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 32
                     iv_length   = 4
                     iv_text_tag = '''' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 36
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 37
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 39
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 40
                     iv_length   = 3
                     iv_text_tag = '|' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 43
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 45
                     iv_length   = 4
                     iv_text_tag = '''' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 49
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 51
                     iv_length   = 1
                     iv_text_tag = '}' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 52
                     iv_length   = 2
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'T'
                     iv_offset   = 54
                     iv_length   = 1
                     iv_text_tag = '}' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

********************************************************
* Check that '*' in select statement is not a match    *
********************************************************
  METHOD test_abap_07.

    DATA lv_line TYPE string.

    lv_line = 'SELECT * FROM foo'.                          ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'K'
                    iv_offset = 0
                    iv_length = 6 ).

    generate_parse( iv_token  = 'K'
                    iv_offset = 9
                    iv_length = 4 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'K'
                    iv_offset   = 0
                    iv_length   = 6
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'K'
                    iv_offset   = 9
                    iv_length   = 4
                    iv_text_tag = '' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'K'
                     iv_offset   = 0
                     iv_length   = 6
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 6
                     iv_length   = 3
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'K'
                     iv_offset   = 9
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 13
                     iv_length   = 4
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

********************************************************
* Test parsing and ordering of key words in structures *
********************************************************
  METHOD test_abap_08.

    DATA lv_line TYPE string.

    lv_line = 'lv_length = <match>-length.'.                ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'K'
                    iv_offset = 13
                    iv_length = 5 ).
    generate_parse( iv_token  = 'K'
                    iv_offset = 20
                    iv_length = 6 ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = '.'
                     iv_offset   = 0
                     iv_length   = 27
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.abap' ).

  ENDMETHOD.

********************************************************
* Test parsing and ordering of tags in xml             *
********************************************************
  METHOD test_xml_01.

    DATA lv_line TYPE string.

    lv_line = '<tag>Text</tag>'.                            ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 4
                    iv_length = 1 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 9
                    iv_length = 1 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 14
                    iv_length = 1 ).

    "" Generate table with expected values after ordering

    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 5
                    iv_text_tag = '<' ).
    generate_order( iv_token    = 'X'
                    iv_offset   = 9
                    iv_length   = 6
                    iv_text_tag = '<' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 5
                     iv_text_tag = '<' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 5
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'X'
                     iv_offset   = 9
                     iv_length   = 6
                     iv_text_tag = '<' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_02.

    DATA lv_line TYPE string.

    lv_line = '<tag/>'.                                     ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 5
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 6
                    iv_text_tag = '<' ).
    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 6
                     iv_text_tag = '<' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_03.

    DATA lv_line TYPE string.

    lv_line = '<tag attribute=""value""/>'.                   ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'A'
                    iv_offset = 4
                    iv_length = 10 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 15
                    iv_length = 7 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 23
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 4
                    iv_text_tag = '<' ).
    generate_order( iv_token    = 'A'
                    iv_offset   = 4
                    iv_length   = 10
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 15
                    iv_length   = 7
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'X'
                    iv_offset   = 22
                    iv_length   = 2
                    iv_text_tag = '>' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 4
                     iv_text_tag = '<' ).
    generate_extend( iv_token    = 'A'
                     iv_offset   = 4
                     iv_length   = 10
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 14
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 15
                     iv_length   = 7
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'X'
                     iv_offset   = 22
                     iv_length   = 2
                     iv_text_tag = '>' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_04.

    DATA lv_line TYPE string.

    lv_line = '<?xml version=""1.0""?>'.                      ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'A'
                    iv_offset = 5
                    iv_length = 8 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 14
                    iv_length = 5 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 20
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 5
                    iv_text_tag = '<' ).
    generate_order( iv_token    = 'A'
                    iv_offset   = 5
                    iv_length   = 8
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 14
                    iv_length   = 5
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'X'
                    iv_offset   = 19
                    iv_length   = 2
                    iv_text_tag = '>' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 5
                     iv_text_tag = '<' ).
    generate_extend( iv_token    = 'A'
                     iv_offset   = 5
                     iv_length   = 8
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 13
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 14
                     iv_length   = 5
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'X'
                     iv_offset   = 19
                     iv_length   = 2
                     iv_text_tag = '>' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_05.

    DATA lv_line TYPE string.

    lv_line = '<ns:tag ns:a1=""v1"" ns:a2=''v2''>""text""</ns:tag>'. ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'A'
                    iv_offset = 7
                    iv_length = 6 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 14
                    iv_length = 4 ).
    generate_parse( iv_token  = 'A'
                    iv_offset = 18
                    iv_length = 6 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 25
                    iv_length = 4 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 29
                    iv_length = 1 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 30
                    iv_length = 6 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 36
                    iv_length = 1 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 44
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 7
                    iv_text_tag = '<' ).
    generate_order( iv_token    = 'A'
                    iv_offset   = 7
                    iv_length   = 6
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 14
                    iv_length   = 4
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'A'
                    iv_offset   = 18
                    iv_length   = 6
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 25
                    iv_length   = 4
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'X'
                    iv_offset   = 29
                    iv_length   = 1
                    iv_text_tag = '>' ).
    generate_order( iv_token    = 'X'
                    iv_offset   = 36
                    iv_length   = 9
                    iv_text_tag = '<' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 7
                     iv_text_tag = '<' ).
    generate_extend( iv_token    = 'A'
                     iv_offset   = 7
                     iv_length   = 6
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 13
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 14
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'A'
                     iv_offset   = 18
                     iv_length   = 6
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 24
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 25
                     iv_length   = 4
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'X'
                     iv_offset   = 29
                     iv_length   = 1
                     iv_text_tag = '>' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 30
                     iv_length   = 6
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'X'
                     iv_offset   = 36
                     iv_length   = 9
                     iv_text_tag = '<' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_06.
    DATA lv_line TYPE string.

    ""unclosed tag
    lv_line = '<ns:tag ns:a1=""v1""'.                         ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'A'
                    iv_offset = 7
                    iv_length = 6 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 14
                    iv_length = 4 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 7
                    iv_text_tag = '<' ).
    generate_order( iv_token    = 'A'
                    iv_offset   = 7
                    iv_length   = 6
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 14
                    iv_length   = 4
                    iv_text_tag = '' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 7
                     iv_text_tag = '<' ).
    generate_extend( iv_token    = 'A'
                     iv_offset   = 7
                     iv_length   = 6
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 13
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 14
                     iv_length   = 4
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).
  ENDMETHOD.

  METHOD test_xml_07.
    ""invalid XML characters in a string
    DATA lv_line TYPE string.

    ""xml special characters in attribute
    lv_line = '<tag attribute="" '' > ""/>'.                  ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'X'
                    iv_offset = 0
                    iv_length = 1 ).
    generate_parse( iv_token  = 'A'
                    iv_offset = 4
                    iv_length = 10 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 15
                    iv_length = 7 ).
    generate_parse( iv_token  = 'X'
                    iv_offset = 23
                    iv_length = 1 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'X'
                    iv_offset   = 0
                    iv_length   = 4
                    iv_text_tag = '<' ).
    generate_order( iv_token    = 'A'
                    iv_offset   = 4
                    iv_length   = 10
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 15
                    iv_length   = 7
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'X'
                    iv_offset   = 22
                    iv_length   = 2
                    iv_text_tag = '>' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'X'
                     iv_offset   = 0
                     iv_length   = 4
                     iv_text_tag = '<' ).
    generate_extend( iv_token    = 'A'
                     iv_offset   = 4
                     iv_length   = 10
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 14
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 15
                     iv_length   = 7
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'X'
                     iv_offset   = 22
                     iv_length   = 2
                     iv_text_tag = '>' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).


  ENDMETHOD.


  METHOD test_xml_08.
    ""invalid XML characters in a string
    DATA lv_line TYPE string.

    ""attribute at beginning of line
    lv_line = 'attribute=''>"" '''.                          ""#EC NOTEXT

    "" Generate table with expected values after parsing
    generate_parse( iv_token  = 'A'
                    iv_offset = 0
                    iv_length = 9 ).
    generate_parse( iv_token  = 'V'
                    iv_offset = 10
                    iv_length = 5 ).

    "" Generate table with expected values after ordering
    generate_order( iv_token    = 'A'
                    iv_offset   = 0
                    iv_length   = 9
                    iv_text_tag = '' ).
    generate_order( iv_token    = 'V'
                    iv_offset   = 10
                    iv_length   = 5
                    iv_text_tag = '' ).

    "" Generate table with expected values after extending
    generate_extend( iv_token    = 'A'
                     iv_offset   = 0
                     iv_length   = 9
                     iv_text_tag = '' ).
    generate_extend( iv_token    = '.'
                     iv_offset   = 9
                     iv_length   = 1
                     iv_text_tag = '' ).
    generate_extend( iv_token    = 'V'
                     iv_offset   = 10
                     iv_length   = 5
                     iv_text_tag = '' ).

    do_test( iv_line = lv_line iv_filename = '*.xml' ).

  ENDMETHOD.


ENDCLASS.

CLASS ltcl_syntax_basic_logic DEFINITION DEFERRED.
CLASS zcl_abapgit_syntax_highlighter DEFINITION LOCAL FRIENDS ltcl_syntax_basic_logic.

*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_basic_logic DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS ltcl_syntax_basic_logic DEFINITION FINAL FOR TESTING RISK LEVEL HARMLESS
    DURATION SHORT.

  PRIVATE SECTION.

    DATA mo_syntax_highlighter TYPE REF TO zcl_abapgit_syntax_highlighter.

    METHODS:
      setup,
      process_line  FOR TESTING,
      format_line   FOR TESTING,
      apply_style   FOR TESTING.

ENDCLASS.

*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_highlighter IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS ltcl_syntax_basic_logic IMPLEMENTATION.

  METHOD setup.
    mo_syntax_highlighter = zcl_abapgit_syntax_highlighter=>create( '*.abap' ).
  ENDMETHOD.

  METHOD format_line.

    DATA:
      lv_line     TYPE string,
      lv_line_act TYPE string,
      lv_line_exp TYPE string.

    lv_line = 'call function ''FM_NAME''. "" Commented'.     ""#EC NOTEXT

    lv_line_exp =
      '<span class=""keyword"">call</span>' &&                ""#EC NOTEXT
      ' <span class=""keyword"">function</span>' &&           ""#EC NOTEXT
      ' <span class=""text"">&#39;FM_NAME&#39;</span>.' &&    ""#EC NOTEXT
      ' <span class=""comment"">&quot; Commented</span>'.     ""#EC NOTEXT

    lv_line_act = mo_syntax_highlighter->process_line( lv_line ).

    cl_abap_unit_assert=>assert_equals( exp = lv_line_exp
                                        act = lv_line_act
                                        msg = | Error during formating: { lv_line }| ).

  ENDMETHOD.

  METHOD apply_style.

    DATA lv_line_act TYPE string.

    "" Call the method and compare results
    lv_line_act = mo_syntax_highlighter->apply_style( iv_line  = 'CALL FUNCTION' ""#EC NOTEXT
                                   iv_class = zcl_abapgit_syntax_abap=>c_css-keyword ).

    cl_abap_unit_assert=>assert_equals(
      act = lv_line_act
      exp = '<span class=""keyword"">CALL FUNCTION</span>'    ""#EC NOTEXT
      msg = 'Failure during applying of style.' ).          ""#EC NOTEXT

  ENDMETHOD.

  METHOD process_line.

    DATA lv_line_act TYPE string.

    "" Call the method with empty parameter and compare results
    lv_line_act = mo_syntax_highlighter->process_line( '' ).

    cl_abap_unit_assert=>assert_equals(
      act = lv_line_act
      exp = ''
      msg = 'Failure in method process_line.' ).            ""#EC NOTEXT

    "" Call the method with non-empty line and compare results
    lv_line_act = mo_syntax_highlighter->process_line( '* CALL FUNCTION' ). ""#EC NOTEXT

    cl_abap_unit_assert=>assert_equals(
      act = lv_line_act
      exp = '<span class=""comment"">* CALL FUNCTION</span>'  ""#EC NOTEXT
      msg = 'Failure in method process_line.' ).            ""#EC NOTEXT

  ENDMETHOD.

ENDCLASS.
",9916,True,2610.2612054600827,median
"/**
 * Copyright (C) 2014 Patrick Mours. All rights reserved.
 * License: https://github.com/crosire/reshade#license
 */

#include ""log.hpp""
#include ""ini_file.hpp""
#include ""runtime_d3d10.hpp""
#include ""runtime_objects.hpp""
#include ""resource_loading.hpp""
#include ""dxgi/format_utils.hpp""
#include <imgui.h>
#include <d3dcompiler.h>

namespace reshade::d3d10
{
	struct d3d10_tex_data : base_object
	{
		com_ptr<ID3D10Texture2D> texture;
		com_ptr<ID3D10ShaderResourceView> srv[2];
		com_ptr<ID3D10RenderTargetView> rtv[2];
	};
	struct d3d10_pass_data : base_object
	{
		com_ptr<ID3D10VertexShader> vertex_shader;
		com_ptr<ID3D10PixelShader> pixel_shader;
		com_ptr<ID3D10BlendState> blend_state;
		com_ptr<ID3D10DepthStencilState> depth_stencil_state;
		UINT stencil_reference;
		bool clear_render_targets;
		com_ptr<ID3D10RenderTargetView> render_targets[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT];
		com_ptr<ID3D10ShaderResourceView> render_target_resources[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT];
		D3D10_VIEWPORT viewport;
		std::vector<com_ptr<ID3D10ShaderResourceView>> shader_resources;
	};
	struct d3d10_technique_data : base_object
	{
		bool query_in_flight = false;
		com_ptr<ID3D10Query> timestamp_disjoint;
		com_ptr<ID3D10Query> timestamp_query_beg;
		com_ptr<ID3D10Query> timestamp_query_end;
		std::vector<com_ptr<ID3D10SamplerState>> sampler_states;
		std::vector<com_ptr<ID3D10ShaderResourceView>> texture_bindings;
		ptrdiff_t uniform_storage_offset = 0;
		ptrdiff_t uniform_storage_index = -1;
	};
}

reshade::d3d10::runtime_d3d10::runtime_d3d10(ID3D10Device1 *device, IDXGISwapChain *swapchain) :
	_device(device), _swapchain(swapchain),
	_app_state(device)
{
	assert(device != nullptr);
	assert(swapchain != nullptr);

	com_ptr<IDXGIDevice> dxgi_device;
	_device->QueryInterface(&dxgi_device);
	com_ptr<IDXGIAdapter> dxgi_adapter;
	dxgi_device->GetAdapter(&dxgi_adapter);

	_renderer_id = device->GetFeatureLevel();
	if (DXGI_ADAPTER_DESC desc; SUCCEEDED(dxgi_adapter->GetDesc(&desc)))
		_vendor_id = desc.VendorId, _device_id = desc.DeviceId;

#if RESHADE_GUI
	subscribe_to_ui(""DX10"", [this]() { draw_debug_menu(); });
#endif
	subscribe_to_load_config([this](const ini_file &config) {
		config.get(""DX10_BUFFER_DETECTION"", ""DepthBufferRetrievalMode"", depth_buffer_before_clear);
		config.get(""DX10_BUFFER_DETECTION"", ""DepthBufferTextureFormat"", depth_buffer_texture_format);
		config.get(""DX10_BUFFER_DETECTION"", ""ExtendedDepthBufferDetection"", extended_depth_buffer_detection);
		config.get(""DX10_BUFFER_DETECTION"", ""DepthBufferClearingNumber"", cleared_depth_buffer_index);
	});
	subscribe_to_save_config([this](ini_file &config) {
		config.set(""DX10_BUFFER_DETECTION"", ""DepthBufferRetrievalMode"", depth_buffer_before_clear);
		config.set(""DX10_BUFFER_DETECTION"", ""DepthBufferTextureFormat"", depth_buffer_texture_format);
		config.set(""DX10_BUFFER_DETECTION"", ""ExtendedDepthBufferDetection"", extended_depth_buffer_detection);
		config.set(""DX10_BUFFER_DETECTION"", ""DepthBufferClearingNumber"", cleared_depth_buffer_index);
	});
}
reshade::d3d10::runtime_d3d10::~runtime_d3d10()
{
	if (_d3d_compiler != nullptr)
		FreeLibrary(_d3d_compiler);
}

bool reshade::d3d10::runtime_d3d10::init_backbuffer_texture()
{
	HRESULT hr = _swapchain->GetBuffer(0, IID_PPV_ARGS(&_backbuffer));
	assert(SUCCEEDED(hr));

	D3D10_TEXTURE2D_DESC tex_desc = {};
	tex_desc.Width = _width;
	tex_desc.Height = _height;
	tex_desc.MipLevels = 1;
	tex_desc.ArraySize = 1;
	tex_desc.Format = make_dxgi_format_typeless(_backbuffer_format);
	tex_desc.SampleDesc = { 1, 0 };
	tex_desc.Usage = D3D10_USAGE_DEFAULT;
	tex_desc.BindFlags = D3D10_BIND_RENDER_TARGET;

	// Creating a render target view for the back buffer fails on Windows 8+, so use a intermediate texture there
	OSVERSIONINFOEX verinfo_windows7 = { sizeof(OSVERSIONINFOEX), 6, 1 };
	const bool is_windows7 = VerifyVersionInfo(&verinfo_windows7, VER_MAJORVERSION | VER_MINORVERSION,
		VerSetConditionMask(VerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL), VER_MINORVERSION, VER_EQUAL)) != FALSE;

	if (_is_multisampling_enabled ||
		make_dxgi_format_normal(_backbuffer_format) != _backbuffer_format ||
		!is_windows7)
	{
		if (hr = _device->CreateTexture2D(&tex_desc, nullptr, &_backbuffer_resolved); FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create back buffer resolve texture (""
				""Width = "" << tex_desc.Width << "", ""
				""Height = "" << tex_desc.Height << "", ""
				""Format = "" << tex_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}

		hr = _device->CreateRenderTargetView(_backbuffer.get(), nullptr, &_backbuffer_rtv[2]);
		assert(SUCCEEDED(hr));
	}
	else
	{
		_backbuffer_resolved = _backbuffer;
	}

	// Create back buffer shader texture
	tex_desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;

	if (hr = _device->CreateTexture2D(&tex_desc, nullptr, &_backbuffer_texture); SUCCEEDED(hr))
	{
		D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
		srv_desc.Format = make_dxgi_format_normal(tex_desc.Format);
		srv_desc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
		srv_desc.Texture2D.MipLevels = tex_desc.MipLevels;

		if (SUCCEEDED(hr))
			hr = _device->CreateShaderResourceView(_backbuffer_texture.get(), &srv_desc, &_backbuffer_texture_srv[0]);
		else
			LOG(ERROR) << ""Failed to create back buffer texture resource view (""
				""Format = "" << srv_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";

		srv_desc.Format = make_dxgi_format_srgb(tex_desc.Format);

		if (SUCCEEDED(hr))
			hr = _device->CreateShaderResourceView(_backbuffer_texture.get(), &srv_desc, &_backbuffer_texture_srv[1]);
		else
			LOG(ERROR) << ""Failed to create back buffer SRGB texture resource view (""
				""Format = "" << srv_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
	}
	else
	{
		LOG(ERROR) << ""Failed to create back buffer texture (""
			""Width = "" << tex_desc.Width << "", ""
			""Height = "" << tex_desc.Height << "", ""
			""Format = "" << tex_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
	}

	if (FAILED(hr))
		return false;

	D3D10_RENDER_TARGET_VIEW_DESC rtv_desc = {};
	rtv_desc.Format = make_dxgi_format_normal(tex_desc.Format);
	rtv_desc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D;

	if (hr = _device->CreateRenderTargetView(_backbuffer_resolved.get(), &rtv_desc, &_backbuffer_rtv[0]); FAILED(hr))
	{
		LOG(ERROR) << ""Failed to create back buffer render target (""
			""Format = "" << rtv_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
		return false;
	}

	rtv_desc.Format = make_dxgi_format_srgb(tex_desc.Format);

	if (hr = _device->CreateRenderTargetView(_backbuffer_resolved.get(), &rtv_desc, &_backbuffer_rtv[1]); FAILED(hr))
	{
		LOG(ERROR) << ""Failed to create back buffer SRGB render target (""
			""Format = "" << rtv_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
		return false;
	}

	const resources::data_resource vs = resources::load_data_resource(IDR_FULLSCREEN_VS);
	if (hr = _device->CreateVertexShader(vs.data, vs.data_size, &_copy_vertex_shader); FAILED(hr))
		return false;
	const resources::data_resource ps = resources::load_data_resource(IDR_COPY_PS);
	if (hr = _device->CreatePixelShader(ps.data, ps.data_size, &_copy_pixel_shader); FAILED(hr))
		return false;

	{   D3D10_SAMPLER_DESC desc = {};
		desc.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT;
		desc.AddressU = D3D10_TEXTURE_ADDRESS_CLAMP;
		desc.AddressV = D3D10_TEXTURE_ADDRESS_CLAMP;
		desc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP;
		if (hr = _device->CreateSamplerState(&desc, &_copy_sampler); FAILED(hr))
			return false;
	}

	{   D3D10_RASTERIZER_DESC desc = {};
		desc.FillMode = D3D10_FILL_SOLID;
		desc.CullMode = D3D10_CULL_NONE;
		desc.DepthClipEnable = TRUE;
		if (hr = _device->CreateRasterizerState(&desc, &_effect_rasterizer_state); FAILED(hr))
			return false;
	}

	return true;
}
bool reshade::d3d10::runtime_d3d10::init_default_depth_stencil()
{
	const D3D10_TEXTURE2D_DESC tex_desc = {
		_width,
		_height,
		1, 1,
		DXGI_FORMAT_D24_UNORM_S8_UINT,
		{ 1, 0 },
		D3D10_USAGE_DEFAULT,
		D3D10_BIND_DEPTH_STENCIL
	};

	com_ptr<ID3D10Texture2D> depth_stencil_texture;

	if (HRESULT hr = _device->CreateTexture2D(&tex_desc, nullptr, &depth_stencil_texture); FAILED(hr))
	{
		LOG(ERROR) << ""Failed to create depth stencil texture (""
			""Width = "" << tex_desc.Width << "", ""
			""Height = "" << tex_desc.Height << "", ""
			""Format = "" << tex_desc.Format << "")! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
		return false;
	}

	return SUCCEEDED(_device->CreateDepthStencilView(depth_stencil_texture.get(), nullptr, &_default_depthstencil));
}

bool reshade::d3d10::runtime_d3d10::on_init(const DXGI_SWAP_CHAIN_DESC &desc)
{
	RECT window_rect = {};
	GetClientRect(desc.OutputWindow, &window_rect);

	_width = desc.BufferDesc.Width;
	_height = desc.BufferDesc.Height;
	_window_width = window_rect.right - window_rect.left;
	_window_height = window_rect.bottom - window_rect.top;
	_backbuffer_format = desc.BufferDesc.Format;
	_is_multisampling_enabled = desc.SampleDesc.Count > 1;

	if (!init_backbuffer_texture() ||
		!init_default_depth_stencil()
#if RESHADE_GUI
		|| !init_imgui_resources()
#endif
		)
		return false;

	return runtime::on_init(desc.OutputWindow);
}
void reshade::d3d10::runtime_d3d10::on_reset()
{
	runtime::on_reset();

	_backbuffer.reset();
	_backbuffer_resolved.reset();
	_backbuffer_texture.reset();
	_backbuffer_texture_srv[0].reset();
	_backbuffer_texture_srv[1].reset();
	_backbuffer_rtv[0].reset();
	_backbuffer_rtv[1].reset();
	_backbuffer_rtv[2].reset();

	_depthstencil.reset();
	_depthstencil_replacement.reset();
	_depthstencil_texture.reset();
	_depthstencil_texture_srv.reset();

	_depth_texture_saves.clear();

	_default_depthstencil.reset();
	_copy_vertex_shader.reset();
	_copy_pixel_shader.reset();
	_copy_sampler.reset();

	_effect_rasterizer_state.reset();

	_imgui_index_buffer_size = 0;
	_imgui_index_buffer.reset();
	_imgui_vertex_buffer_size = 0;
	_imgui_vertex_buffer.reset();
	_imgui_vertex_shader.reset();
	_imgui_pixel_shader.reset();
	_imgui_input_layout.reset();
	_imgui_constant_buffer.reset();
	_imgui_texture_sampler.reset();
	_imgui_rasterizer_state.reset();
	_imgui_blend_state.reset();
	_imgui_depthstencil_state.reset();
}

void reshade::d3d10::runtime_d3d10::on_present(draw_call_tracker &tracker)
{
	if (!_is_initialized)
		return;

	_vertices = tracker.total_vertices();
	_drawcalls = tracker.total_drawcalls();
	_current_tracker = &tracker;

#if RESHADE_DX10_CAPTURE_DEPTH_BUFFERS
	detect_depth_source(tracker);
#endif
	_app_state.capture();

	// Resolve MSAA back buffer if MSAA is active
	if (_backbuffer_resolved != _backbuffer)
		_device->ResolveSubresource(_backbuffer_resolved.get(), 0, _backbuffer.get(), 0, _backbuffer_format);

	update_and_render_effects();
	runtime::on_present();

	// Stretch main render target back into MSAA back buffer if MSAA is active
	if (_backbuffer_resolved != _backbuffer)
	{
		_device->CopyResource(_backbuffer_texture.get(), _backbuffer_resolved.get());

		_device->IASetInputLayout(nullptr);
		const uintptr_t null = 0;
		_device->IASetVertexBuffers(0, 1, reinterpret_cast<ID3D10Buffer *const *>(&null), reinterpret_cast<const UINT *>(&null), reinterpret_cast<const UINT *>(&null));
		_device->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
		_device->VSSetShader(_copy_vertex_shader.get());
		_device->GSSetShader(nullptr);
		_device->PSSetShader(_copy_pixel_shader.get());
		ID3D10SamplerState *const samplers[] = { _copy_sampler.get() };
		_device->PSSetSamplers(0, ARRAYSIZE(samplers), samplers);
		ID3D10ShaderResourceView *const srvs[] = { _backbuffer_texture_srv[make_dxgi_format_srgb(_backbuffer_format) == _backbuffer_format].get() };
		_device->PSSetShaderResources(0, ARRAYSIZE(srvs), srvs);
		_device->RSSetState(_effect_rasterizer_state.get());
		const D3D10_VIEWPORT viewport = { 0, 0, _width, _height, 0.0f, 1.0f };
		_device->RSSetViewports(1, &viewport);
		_device->OMSetBlendState(nullptr, nullptr, D3D10_DEFAULT_SAMPLE_MASK);
		_device->OMSetDepthStencilState(nullptr, D3D10_DEFAULT_STENCIL_REFERENCE);
		ID3D10RenderTargetView *const render_targets[] = { _backbuffer_rtv[2].get() };
		_device->OMSetRenderTargets(ARRAYSIZE(render_targets), render_targets, nullptr);

		_device->Draw(3, 0);
	}

	// Apply previous state from application
	_app_state.apply_and_release();
}

void reshade::d3d10::runtime_d3d10::capture_screenshot(uint8_t *buffer) const
{
	if (_backbuffer_format != DXGI_FORMAT_R8G8B8A8_UNORM &&
		_backbuffer_format != DXGI_FORMAT_R8G8B8A8_UNORM_SRGB &&
		_backbuffer_format != DXGI_FORMAT_B8G8R8A8_UNORM &&
		_backbuffer_format != DXGI_FORMAT_B8G8R8A8_UNORM_SRGB)
	{
		LOG(WARN) << ""Screenshots are not supported for back buffer format "" << _backbuffer_format << '.';
		return;
	}

	// Create a texture in system memory, copy back buffer data into it and map it for reading
	D3D10_TEXTURE2D_DESC desc = {};
	desc.Width = _width;
	desc.Height = _height;
	desc.MipLevels = 1;
	desc.ArraySize = 1;
	desc.Format = _backbuffer_format;
	desc.SampleDesc = { 1, 0 };
	desc.Usage = D3D10_USAGE_STAGING;
	desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;

	com_ptr<ID3D10Texture2D> intermediate;
	if (FAILED(_device->CreateTexture2D(&desc, nullptr, &intermediate)))
	{
		LOG(ERROR) << ""Failed to create system memory texture for screenshot capture!"";
		return;
	}

	_device->CopyResource(intermediate.get(), _backbuffer_resolved.get());

	D3D10_MAPPED_TEXTURE2D mapped;
	if (FAILED(intermediate->Map(0, D3D10_MAP_READ, 0, &mapped)))
		return;
	auto mapped_data = static_cast<uint8_t *>(mapped.pData);

	for (uint32_t y = 0, pitch = _width * 4; y < _height; y++, buffer += pitch, mapped_data += mapped.RowPitch)
	{
		memcpy(buffer, mapped_data, pitch);

		for (uint32_t x = 0; x < pitch; x += 4)
		{
			buffer[x + 3] = 0xFF; // Clear alpha channel
			if (_backbuffer_format == DXGI_FORMAT_B8G8R8A8_UNORM || _backbuffer_format == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB)
				std::swap(buffer[x + 0], buffer[x + 2]); // Format is BGRA, but output should be RGBA, so flip channels
		}
	}

	intermediate->Unmap(0);
}

bool reshade::d3d10::runtime_d3d10::init_texture(texture &info)
{
	info.impl = std::make_unique<d3d10_tex_data>();

	if (info.impl_reference != texture_reference::none)
		return update_texture_reference(info);

	D3D10_TEXTURE2D_DESC desc = {};
	desc.Width = info.width;
	desc.Height = info.height;
	desc.MipLevels = info.levels;
	desc.ArraySize = 1;
	desc.SampleDesc = { 1, 0 };
	desc.Usage = D3D10_USAGE_DEFAULT;
	desc.BindFlags = D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET;
	desc.MiscFlags = D3D10_RESOURCE_MISC_GENERATE_MIPS;

	switch (info.format)
	{
	case reshadefx::texture_format::r8:
		desc.Format = DXGI_FORMAT_R8_UNORM;
		break;
	case reshadefx::texture_format::r16f:
		desc.Format = DXGI_FORMAT_R16_FLOAT;
		break;
	case reshadefx::texture_format::r32f:
		desc.Format = DXGI_FORMAT_R32_FLOAT;
		break;
	case reshadefx::texture_format::rg8:
		desc.Format = DXGI_FORMAT_R8G8_UNORM;
		break;
	case reshadefx::texture_format::rg16:
		desc.Format = DXGI_FORMAT_R16G16_UNORM;
		break;
	case reshadefx::texture_format::rg16f:
		desc.Format = DXGI_FORMAT_R16G16_FLOAT;
		break;
	case reshadefx::texture_format::rg32f:
		desc.Format = DXGI_FORMAT_R32G32_FLOAT;
		break;
	case reshadefx::texture_format::rgba8:
		desc.Format = DXGI_FORMAT_R8G8B8A8_TYPELESS;
		break;
	case reshadefx::texture_format::rgba16:
		desc.Format = DXGI_FORMAT_R16G16B16A16_UNORM;
		break;
	case reshadefx::texture_format::rgba16f:
		desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
		break;
	case reshadefx::texture_format::rgba32f:
		desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
		break;
	case reshadefx::texture_format::dxt1:
		desc.Format = DXGI_FORMAT_BC1_TYPELESS;
		break;
	case reshadefx::texture_format::dxt3:
		desc.Format = DXGI_FORMAT_BC2_TYPELESS;
		break;
	case reshadefx::texture_format::dxt5:
		desc.Format = DXGI_FORMAT_BC3_TYPELESS;
		break;
	case reshadefx::texture_format::latc1:
		desc.Format = DXGI_FORMAT_BC4_UNORM;
		break;
	case reshadefx::texture_format::latc2:
		desc.Format = DXGI_FORMAT_BC5_UNORM;
		break;
	}

	const auto texture_data = info.impl->as<d3d10_tex_data>();

	if (HRESULT hr = _device->CreateTexture2D(&desc, nullptr, &texture_data->texture); FAILED(hr))
	{
		LOG(ERROR) << ""Failed to create texture '"" << info.unique_name << ""' (""
			""Width = "" << desc.Width << "", ""
			""Height = "" << desc.Height << "", ""
			""Format = "" << desc.Format << "")! ""
			""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
		return false;
	}

	D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
	srv_desc.Format = make_dxgi_format_normal(desc.Format);
	srv_desc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
	srv_desc.Texture2D.MipLevels = desc.MipLevels;

	if (HRESULT hr = _device->CreateShaderResourceView(texture_data->texture.get(), &srv_desc, &texture_data->srv[0]); FAILED(hr))
	{
		LOG(ERROR) << ""Failed to create shader resource view for texture '"" << info.unique_name << ""' (""
			""Format = "" << srv_desc.Format << "")! ""
			""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
		return false;
	}

	srv_desc.Format = make_dxgi_format_srgb(desc.Format);

	if (srv_desc.Format != desc.Format)
	{
		if (HRESULT hr = _device->CreateShaderResourceView(texture_data->texture.get(), &srv_desc, &texture_data->srv[1]); FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create shader resource view for texture '"" << info.unique_name << ""' (""
				""Format = "" << srv_desc.Format << "")! ""
				""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}
	}
	else
	{
		texture_data->srv[1] = texture_data->srv[0];
	}

	return true;
}
void reshade::d3d10::runtime_d3d10::upload_texture(texture &texture, const uint8_t *pixels)
{
	assert(texture.impl_reference == texture_reference::none && pixels != nullptr);

	unsigned int upload_pitch;
	std::vector<uint8_t> upload_data;

	switch (texture.format)
	{
	case reshadefx::texture_format::r8:
		upload_pitch = texture.width;
		upload_data.resize(upload_pitch * texture.height);
		for (uint32_t i = 0, k = 0; i < texture.width * texture.height * 4; i += 4, k += 1)
			upload_data[k] = pixels[i];
		pixels = upload_data.data();
		break;
	case reshadefx::texture_format::rg8:
		upload_pitch = texture.width * 2;
		upload_data.resize(upload_pitch * texture.height);
		for (uint32_t i = 0, k = 0; i < texture.width * texture.height * 4; i += 4, k += 2)
			upload_data[k + 0] = pixels[i + 0],
			upload_data[k + 1] = pixels[i + 1];
		pixels = upload_data.data();
		break;
	case reshadefx::texture_format::rgba8:
		upload_pitch = texture.width * 4;
		break;
	default:
		LOG(ERROR) << ""Texture upload is not supported for format "" << static_cast<unsigned int>(texture.format) << '!';
		return;
	}

	const auto texture_impl = texture.impl->as<d3d10_tex_data>();
	assert(texture_impl != nullptr);

	_device->UpdateSubresource(texture_impl->texture.get(), 0, nullptr, pixels, upload_pitch, upload_pitch * texture.height);

	if (texture.levels > 1)
		_device->GenerateMips(texture_impl->srv[0].get());
}
bool reshade::d3d10::runtime_d3d10::update_texture_reference(texture &texture)
{
	com_ptr<ID3D10ShaderResourceView> new_reference[2];

	switch (texture.impl_reference)
	{
	case texture_reference::back_buffer:
		new_reference[0] = _backbuffer_texture_srv[0];
		new_reference[1] = _backbuffer_texture_srv[1];
		break;
	case texture_reference::depth_buffer:
		new_reference[0] = _depthstencil_texture_srv;
		new_reference[1] = _depthstencil_texture_srv;
		break;
	default:
		return false;
	}

	const auto texture_impl = texture.impl->as<d3d10_tex_data>();
	assert(texture_impl != nullptr);

	if (new_reference[0] == texture_impl->srv[0] &&
		new_reference[1] == texture_impl->srv[1])
		return true;

	// Update references in technique list
	for (const auto &technique : _techniques)
		for (const auto &pass : technique.passes_data)
			for (auto &srv : pass->as<d3d10_pass_data>()->shader_resources)
				if (srv == texture_impl->srv[0]) srv = new_reference[0];
				else if (srv == texture_impl->srv[1]) srv = new_reference[1];

	texture.width = frame_width();
	texture.height = frame_height();

	texture_impl->srv[0] = new_reference[0];
	texture_impl->srv[1] = new_reference[1];

	return true;
}
void reshade::d3d10::runtime_d3d10::update_texture_references(texture_reference type)
{
	for (auto &tex : _textures)
		if (tex.impl != nullptr && tex.impl_reference == type)
			update_texture_reference(tex);
}

bool reshade::d3d10::runtime_d3d10::compile_effect(effect_data &effect)
{
	if (_d3d_compiler == nullptr)
		_d3d_compiler = LoadLibraryW(L""d3dcompiler_47.dll"");
	if (_d3d_compiler == nullptr)
		_d3d_compiler = LoadLibraryW(L""d3dcompiler_43.dll"");

	if (_d3d_compiler == nullptr)
	{
		LOG(ERROR) << ""Unable to load HLSL compiler (\\""d3dcompiler_47.dll\\""). Make sure you have the DirectX end-user runtime (June 2010) installed or a newer version of the library in the application directory."";
		return false;
	}

	const auto D3DCompile = reinterpret_cast<pD3DCompile>(GetProcAddress(_d3d_compiler, ""D3DCompile""));

	const std::string hlsl = effect.preamble + effect.module.hlsl;
	std::unordered_map<std::string, com_ptr<IUnknown>> entry_points;

	// Compile the generated HLSL source code to DX byte code
	for (const auto &entry_point : effect.module.entry_points)
	{
		std::string profile = entry_point.second ? ""ps"" : ""vs"";

		switch (_renderer_id)
		{
		case D3D10_FEATURE_LEVEL_10_1:
			profile += ""_4_1"";
			break;
		default:
		case D3D10_FEATURE_LEVEL_10_0:
			profile += ""_4_0"";
			break;
		case D3D10_FEATURE_LEVEL_9_1:
		case D3D10_FEATURE_LEVEL_9_2:
			profile += ""_4_0_level_9_1"";
			break;
		case D3D10_FEATURE_LEVEL_9_3:
			profile += ""_4_0_level_9_3"";
			break;
		}

		com_ptr<ID3DBlob> d3d_compiled, d3d_errors;

		HRESULT hr = D3DCompile(hlsl.c_str(), hlsl.size(), nullptr, nullptr, nullptr, entry_point.first.c_str(), profile.c_str(), D3DCOMPILE_ENABLE_STRICTNESS, 0, &d3d_compiled, &d3d_errors);

		if (d3d_errors != nullptr) // Append warnings to the output error string as well
			effect.errors.append(static_cast<const char *>(d3d_errors->GetBufferPointer()), d3d_errors->GetBufferSize() - 1); // Subtracting one to not append the null-terminator as well

		// No need to setup resources if any of the shaders failed to compile
		if (FAILED(hr))
			return false;

		// Create runtime shader objects from the compiled DX byte code
		if (entry_point.second)
			hr = _device->CreatePixelShader(d3d_compiled->GetBufferPointer(), d3d_compiled->GetBufferSize(), reinterpret_cast<ID3D10PixelShader **>(&entry_points[entry_point.first]));
		else
			hr = _device->CreateVertexShader(d3d_compiled->GetBufferPointer(), d3d_compiled->GetBufferSize(), reinterpret_cast<ID3D10VertexShader **>(&entry_points[entry_point.first]));

		if (FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create shader for entry point '"" << entry_point.first << ""'. ""
				""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}
	}

	if (effect.storage_size != 0)
	{
		com_ptr<ID3D10Buffer> cbuffer;

		const D3D10_BUFFER_DESC desc = { static_cast<UINT>(effect.storage_size), D3D10_USAGE_DYNAMIC, D3D10_BIND_CONSTANT_BUFFER, D3D10_CPU_ACCESS_WRITE };
		const D3D10_SUBRESOURCE_DATA init_data = { _uniform_data_storage.data() + effect.storage_offset, static_cast<UINT>(effect.storage_size) };

		if (HRESULT hr = _device->CreateBuffer(&desc, &init_data, &cbuffer); FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create constant buffer for effect file "" << effect.source_file << "". ""
				""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}

		_constant_buffers.push_back(std::move(cbuffer));
	}

	bool success = true;

	d3d10_technique_data technique_init;
	technique_init.uniform_storage_index = _constant_buffers.size() - 1;
	technique_init.uniform_storage_offset = effect.storage_offset;

	for (const reshadefx::sampler_info &info : effect.module.samplers)
		success &= add_sampler(info, technique_init);

	for (technique &technique : _techniques)
		if (technique.impl == nullptr && technique.effect_index == effect.index)
			success &= init_technique(technique, technique_init, entry_points);

	return success;
}
void reshade::d3d10::runtime_d3d10::unload_effects()
{
	runtime::unload_effects();

	_effect_sampler_states.clear();
	_constant_buffers.clear();
}

bool reshade::d3d10::runtime_d3d10::add_sampler(const reshadefx::sampler_info &info, d3d10_technique_data &technique_init)
{
	if (info.binding >= D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)
	{
		LOG(ERROR) << ""Cannot bind sampler '"" << info.unique_name << ""' since it exceeds the maximum number of allowed sampler slots in D3D10 ("" << info.binding << "", allowed are up to "" << D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT << "")."";
		return false;
	}
	if (info.texture_binding >= D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)
	{
		LOG(ERROR) << ""Cannot bind texture '"" << info.texture_name << ""' since it exceeds the maximum number of allowed resource slots in D3D10 ("" << info.texture_binding << "", allowed are up to "" << D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT << "")."";
		return false;
	}

	const auto existing_texture = std::find_if(_textures.begin(), _textures.end(),
		[&texture_name = info.texture_name](const auto &item) {
		return item.unique_name == texture_name && item.impl != nullptr;
	});

	if (existing_texture == _textures.end())
		return false;

	D3D10_SAMPLER_DESC desc = {};
	desc.Filter = static_cast<D3D10_FILTER>(info.filter);
	desc.AddressU = static_cast<D3D10_TEXTURE_ADDRESS_MODE>(info.address_u);
	desc.AddressV = static_cast<D3D10_TEXTURE_ADDRESS_MODE>(info.address_v);
	desc.AddressW = static_cast<D3D10_TEXTURE_ADDRESS_MODE>(info.address_w);
	desc.MipLODBias = info.lod_bias;
	desc.MaxAnisotropy = 1;
	desc.ComparisonFunc = D3D10_COMPARISON_NEVER;
	desc.MinLOD = info.min_lod;
	desc.MaxLOD = info.max_lod;

	// Generate hash for sampler description
	size_t desc_hash = 2166136261;
	for (size_t i = 0; i < sizeof(desc); ++i)
		desc_hash = (desc_hash * 16777619) ^ reinterpret_cast<const uint8_t *>(&desc)[i];

	auto it = _effect_sampler_states.find(desc_hash);
	if (it == _effect_sampler_states.end())
	{
		com_ptr<ID3D10SamplerState> sampler;

		HRESULT hr = _device->CreateSamplerState(&desc, &sampler);

		if (FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create sampler state for sampler '"" << info.unique_name << ""' (""
				""Filter = "" << desc.Filter << "", ""
				""AddressU = "" << desc.AddressU << "", ""
				""AddressV = "" << desc.AddressV << "", ""
				""AddressW = "" << desc.AddressW << "", ""
				""MipLODBias = "" << desc.MipLODBias << "", ""
				""MinLOD = "" << desc.MinLOD << "", ""
				""MaxLOD = "" << desc.MaxLOD << "")! ""
				""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}

		it = _effect_sampler_states.emplace(desc_hash, std::move(sampler)).first;
	}

	technique_init.sampler_states.resize(std::max(technique_init.sampler_states.size(), size_t(info.binding + 1)));
	technique_init.texture_bindings.resize(std::max(technique_init.texture_bindings.size(), size_t(info.texture_binding + 1)));

	technique_init.sampler_states[info.binding] = it->second;
	technique_init.texture_bindings[info.texture_binding] = existing_texture->impl->as<d3d10_tex_data>()->srv[info.srgb ? 1 : 0];

	return true;
}
bool reshade::d3d10::runtime_d3d10::init_technique(technique &technique, const d3d10_technique_data &impl_init, const std::unordered_map<std::string, com_ptr<IUnknown>> &entry_points)
{
	// Copy construct new technique implementation instead of move because effect may contain multiple techniques
	technique.impl = std::make_unique<d3d10_technique_data>(impl_init);

	const auto technique_data = technique.impl->as<d3d10_technique_data>();

	D3D10_QUERY_DESC query_desc = {};
	query_desc.Query = D3D10_QUERY_TIMESTAMP;
	_device->CreateQuery(&query_desc, &technique_data->timestamp_query_beg);
	_device->CreateQuery(&query_desc, &technique_data->timestamp_query_end);
	query_desc.Query = D3D10_QUERY_TIMESTAMP_DISJOINT;
	_device->CreateQuery(&query_desc, &technique_data->timestamp_disjoint);

	for (size_t pass_index = 0; pass_index < technique.passes.size(); ++pass_index)
	{
		technique.passes_data.push_back(std::make_unique<d3d10_pass_data>());

		auto &pass = *technique.passes_data.back()->as<d3d10_pass_data>();
		const auto &pass_info = technique.passes[pass_index];

		entry_points.at(pass_info.ps_entry_point)->QueryInterface(&pass.pixel_shader);
		entry_points.at(pass_info.vs_entry_point)->QueryInterface(&pass.vertex_shader);

		pass.viewport.MaxDepth = 1.0f;
		pass.viewport.Width = pass_info.viewport_width;
		pass.viewport.Height = pass_info.viewport_height;

		pass.shader_resources = technique_data->texture_bindings;
		pass.clear_render_targets = pass_info.clear_render_targets;

		const int target_index = pass_info.srgb_write_enable ? 1 : 0;
		pass.render_targets[0] = _backbuffer_rtv[target_index];
		pass.render_target_resources[0] = _backbuffer_texture_srv[target_index];

		for (unsigned int k = 0; k < 8; k++)
		{
			if (pass_info.render_target_names[k].empty())
				continue; // Skip unbound render targets

			const auto render_target_texture = std::find_if(_textures.begin(), _textures.end(),
				[&render_target = pass_info.render_target_names[k]](const auto &item) {
				return item.unique_name == render_target;
			});

			if (render_target_texture == _textures.end())
				return assert(false), false;

			const auto texture_impl = render_target_texture->impl->as<d3d10_tex_data>();
			assert(texture_impl != nullptr);

			D3D10_TEXTURE2D_DESC desc;
			texture_impl->texture->GetDesc(&desc);

			D3D10_RENDER_TARGET_VIEW_DESC rtv_desc = {};
			rtv_desc.Format = pass_info.srgb_write_enable ? make_dxgi_format_srgb(desc.Format) : make_dxgi_format_normal(desc.Format);
			rtv_desc.ViewDimension = desc.SampleDesc.Count > 1 ? D3D10_RTV_DIMENSION_TEXTURE2DMS : D3D10_RTV_DIMENSION_TEXTURE2D;

			if (texture_impl->rtv[target_index] == nullptr)
				if (HRESULT hr = _device->CreateRenderTargetView(texture_impl->texture.get(), &rtv_desc, &texture_impl->rtv[target_index]); FAILED(hr))
				{
					LOG(ERROR) << ""Failed to create render target view for texture '"" << render_target_texture->unique_name << ""' (""
						""Format = "" << rtv_desc.Format << "")! ""
						""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
					return false;
				}

			pass.render_targets[k] = texture_impl->rtv[target_index];
			pass.render_target_resources[k] = texture_impl->srv[target_index];
		}

		if (pass.viewport.Width == 0)
		{
			pass.viewport.Width = frame_width();
			pass.viewport.Height = frame_height();
		}

		{   D3D10_BLEND_DESC desc = {};
			desc.BlendEnable[0] = pass_info.blend_enable;

			const auto literal_to_blend_func = [](unsigned int value) {
				switch (value) {
				case 0:
					return D3D10_BLEND_ZERO;
				default:
				case 1:
					return D3D10_BLEND_ONE;
				case 2:
					return D3D10_BLEND_SRC_COLOR;
				case 4:
					return D3D10_BLEND_INV_SRC_COLOR;
				case 3:
					return D3D10_BLEND_SRC_ALPHA;
				case 5:
					return D3D10_BLEND_INV_SRC_ALPHA;
				case 6:
					return D3D10_BLEND_DEST_ALPHA;
				case 7:
					return D3D10_BLEND_INV_DEST_ALPHA;
				case 8:
					return D3D10_BLEND_DEST_COLOR;
				case 9:
					return D3D10_BLEND_INV_DEST_COLOR;
				}
			};

			desc.SrcBlend = literal_to_blend_func(pass_info.src_blend);
			desc.DestBlend = literal_to_blend_func(pass_info.dest_blend);
			desc.BlendOp = static_cast<D3D10_BLEND_OP>(pass_info.blend_op);
			desc.SrcBlendAlpha = literal_to_blend_func(pass_info.src_blend_alpha);
			desc.DestBlendAlpha = literal_to_blend_func(pass_info.dest_blend_alpha);
			desc.BlendOpAlpha = static_cast<D3D10_BLEND_OP>(pass_info.blend_op_alpha);
			desc.RenderTargetWriteMask[0] = pass_info.color_write_mask;

			for (UINT i = 1; i < 8; ++i)
			{
				desc.BlendEnable[i] = desc.BlendEnable[0];
				desc.RenderTargetWriteMask[i] = desc.RenderTargetWriteMask[0];
			}

			if (HRESULT hr = _device->CreateBlendState(&desc, &pass.blend_state); FAILED(hr))
			{
				LOG(ERROR) << ""Failed to create blend state for pass "" << pass_index << "" in technique '"" << technique.name << ""'! ""
					""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
				return false;
			}
		}

		// Rasterizer state is the same for all passes
		assert(_effect_rasterizer_state != nullptr);

		{   D3D10_DEPTH_STENCIL_DESC desc = {};
			desc.DepthEnable = FALSE;
			desc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ZERO;
			desc.DepthFunc = D3D10_COMPARISON_ALWAYS;

			const auto literal_to_stencil_op = [](unsigned int value) {
				switch (value) {
				default:
				case 1:
					return D3D10_STENCIL_OP_KEEP;
				case 0:
					return D3D10_STENCIL_OP_ZERO;
				case 3:
					return D3D10_STENCIL_OP_REPLACE;
				case 4:
					return D3D10_STENCIL_OP_INCR_SAT;
				case 5:
					return D3D10_STENCIL_OP_DECR_SAT;
				case 6:
					return D3D10_STENCIL_OP_INVERT;
				case 7:
					return D3D10_STENCIL_OP_INCR;
				case 8:
					return D3D10_STENCIL_OP_DECR;
				}
			};

			desc.StencilEnable = pass_info.stencil_enable;
			desc.StencilReadMask = pass_info.stencil_read_mask;
			desc.StencilWriteMask = pass_info.stencil_write_mask;
			desc.FrontFace.StencilFailOp = literal_to_stencil_op(pass_info.stencil_op_fail);
			desc.FrontFace.StencilDepthFailOp = literal_to_stencil_op(pass_info.stencil_op_depth_fail);
			desc.FrontFace.StencilPassOp = literal_to_stencil_op(pass_info.stencil_op_pass);
			desc.FrontFace.StencilFunc = static_cast<D3D10_COMPARISON_FUNC>(pass_info.stencil_comparison_func);
			desc.BackFace = desc.FrontFace;
			if (HRESULT hr = _device->CreateDepthStencilState(&desc, &pass.depth_stencil_state); FAILED(hr))
			{
				LOG(ERROR) << ""Failed to create depth stencil state for pass "" << pass_index << "" in technique '"" << technique.name << ""'! ""
					""HRESULT is '"" << std::hex << hr << std::dec << ""'."";
				return false;
			}

			pass.stencil_reference = pass_info.stencil_reference_value;
		}

		for (auto &srv : pass.shader_resources)
		{
			if (srv == nullptr)
				continue;

			com_ptr<ID3D10Resource> res1;
			srv->GetResource(&res1);

			for (const auto &rtv : pass.render_targets)
			{
				if (rtv == nullptr)
					continue;

				com_ptr<ID3D10Resource> res2;
				rtv->GetResource(&res2);

				if (res1 == res2)
				{
					srv.reset();
					break;
				}
			}
		}
	}

	return true;
}

void reshade::d3d10::runtime_d3d10::render_technique(technique &technique)
{
	d3d10_technique_data &technique_data = *technique.impl->as<d3d10_technique_data>();

	// Evaluate queries
	if (technique_data.query_in_flight)
	{
		UINT64 timestamp0, timestamp1;
		D3D10_QUERY_DATA_TIMESTAMP_DISJOINT disjoint;

		if (technique_data.timestamp_disjoint->GetData(&disjoint, sizeof(disjoint), D3D10_ASYNC_GETDATA_DONOTFLUSH) == S_OK &&
			technique_data.timestamp_query_beg->GetData(&timestamp0, sizeof(timestamp0), D3D10_ASYNC_GETDATA_DONOTFLUSH) == S_OK &&
			technique_data.timestamp_query_end->GetData(&timestamp1, sizeof(timestamp1), D3D10_ASYNC_GETDATA_DONOTFLUSH) == S_OK)
		{
			if (!disjoint.Disjoint)
				technique.average_gpu_duration.append((timestamp1 - timestamp0) * 1'000'000'000 / disjoint.Frequency);
			technique_data.query_in_flight = false;
		}
	}

	if (!technique_data.query_in_flight)
	{
		technique_data.timestamp_disjoint->Begin();
		technique_data.timestamp_query_beg->End();
	}

	bool is_default_depthstencil_cleared = false;

	// Setup vertex input
	const uintptr_t null = 0;
	_device->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	_device->IASetInputLayout(nullptr);
	_device->IASetVertexBuffers(0, 1, reinterpret_cast<ID3D10Buffer *const *>(&null), reinterpret_cast<const UINT *>(&null), reinterpret_cast<const UINT *>(&null));

	_device->RSSetState(_effect_rasterizer_state.get());

	// Setup samplers
	_device->VSSetSamplers(0, static_cast<UINT>(technique_data.sampler_states.size()), reinterpret_cast<ID3D10SamplerState *const *>(technique_data.sampler_states.data()));
	_device->PSSetSamplers(0, static_cast<UINT>(technique_data.sampler_states.size()), reinterpret_cast<ID3D10SamplerState *const *>(technique_data.sampler_states.data()));

	// Setup shader constants
	if (technique_data.uniform_storage_index >= 0)
	{
		void *data = nullptr;
		D3D10_BUFFER_DESC desc = {};
		const auto constant_buffer = _constant_buffers[technique_data.uniform_storage_index].get();

		constant_buffer->GetDesc(&desc);
		const HRESULT hr = constant_buffer->Map(D3D10_MAP_WRITE_DISCARD, 0, &data);

		if (SUCCEEDED(hr))
		{
			memcpy(data, _uniform_data_storage.data() + technique_data.uniform_storage_offset, desc.ByteWidth);

			constant_buffer->Unmap();
		}
		else
		{
			LOG(ERROR) << ""Failed to map constant buffer! HRESULT is '"" << std::hex << hr << std::dec << ""'!"";
		}

		_device->VSSetConstantBuffers(0, 1, &constant_buffer);
		_device->PSSetConstantBuffers(0, 1, &constant_buffer);
	}

	// Disable unused shader stages
	_device->GSSetShader(nullptr);

	for (const auto &pass_object : technique.passes_data)
	{
		const d3d10_pass_data &pass = *pass_object->as<d3d10_pass_data>();

		// Setup states
		_device->VSSetShader(pass.vertex_shader.get());
		_device->PSSetShader(pass.pixel_shader.get());

		_device->OMSetBlendState(pass.blend_state.get(), nullptr, D3D10_DEFAULT_SAMPLE_MASK);
		_device->OMSetDepthStencilState(pass.depth_stencil_state.get(), pass.stencil_reference);

		// Save back buffer of previous pass
		_device->CopyResource(_backbuffer_texture.get(), _backbuffer_resolved.get());

		// Setup shader resources
		_device->VSSetShaderResources(0, static_cast<UINT>(pass.shader_resources.size()), reinterpret_cast<ID3D10ShaderResourceView *const *>(pass.shader_resources.data()));
		_device->PSSetShaderResources(0, static_cast<UINT>(pass.shader_resources.size()), reinterpret_cast<ID3D10ShaderResourceView *const *>(pass.shader_resources.data()));

		// Setup render targets
		if (pass.viewport.Width == _width && pass.viewport.Height == _height)
		{
			_device->OMSetRenderTargets(D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT, reinterpret_cast<ID3D10RenderTargetView *const *>(pass.render_targets), _default_depthstencil.get());

			if (!is_default_depthstencil_cleared)
			{
				is_default_depthstencil_cleared = true;

				_device->ClearDepthStencilView(_default_depthstencil.get(), D3D10_CLEAR_DEPTH | D3D10_CLEAR_STENCIL, 1.0f, 0);
			}
		}
		else
		{
			_device->OMSetRenderTargets(D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT, reinterpret_cast<ID3D10RenderTargetView *const *>(pass.render_targets), nullptr);
		}

		_device->RSSetViewports(1, &pass.viewport);

		if (pass.clear_render_targets)
		{
			for (const auto &target : pass.render_targets)
			{
				if (target != nullptr)
				{
					const float color[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
					_device->ClearRenderTargetView(target.get(), color);
				}
			}
		}

		// Draw triangle
		_device->Draw(3, 0);

		_vertices += 3;
		_drawcalls += 1;

		// Reset render targets
		_device->OMSetRenderTargets(0, nullptr, nullptr);

		// Reset shader resources
		ID3D10ShaderResourceView *null_srv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { nullptr };
		_device->VSSetShaderResources(0, static_cast<UINT>(pass.shader_resources.size()), null_srv);
		_device->PSSetShaderResources(0, static_cast<UINT>(pass.shader_resources.size()), null_srv);

		// Update shader resources
		for (const auto &resource : pass.render_target_resources)
		{
			if (resource == nullptr)
				continue;

			D3D10_SHADER_RESOURCE_VIEW_DESC resource_desc;
			resource->GetDesc(&resource_desc);

			if (resource_desc.Texture2D.MipLevels > 1)
				_device->GenerateMips(resource.get());
		}
	}

	if (!technique_data.query_in_flight)
	{
		technique_data.timestamp_query_end->End();
		technique_data.timestamp_disjoint->End();
		technique_data.query_in_flight = true;
	}
}

#if RESHADE_GUI
bool reshade::d3d10::runtime_d3d10::init_imgui_resources()
{
	{   const resources::data_resource vs = resources::load_data_resource(IDR_IMGUI_VS);
		if (FAILED(_device->CreateVertexShader(vs.data, vs.data_size, &_imgui_vertex_shader)))
			return false;

		const D3D10_INPUT_ELEMENT_DESC input_layout[] = {
			{ ""POSITION"", 0, DXGI_FORMAT_R32G32_FLOAT,   0, offsetof(ImDrawVert, pos), D3D10_INPUT_PER_VERTEX_DATA, 0 },
			{ ""TEXCOORD"", 0, DXGI_FORMAT_R32G32_FLOAT,   0, offsetof(ImDrawVert, uv ), D3D10_INPUT_PER_VERTEX_DATA, 0 },
			{ ""COLOR"",    0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, offsetof(ImDrawVert, col), D3D10_INPUT_PER_VERTEX_DATA, 0 },
		};
		if (FAILED(_device->CreateInputLayout(input_layout, _countof(input_layout), vs.data, vs.data_size, &_imgui_input_layout)))
			return false;
	}

	{   const resources::data_resource ps = resources::load_data_resource(IDR_IMGUI_PS);
		if (FAILED(_device->CreatePixelShader(ps.data, ps.data_size, &_imgui_pixel_shader)))
			return false;
	}

	{   D3D10_BUFFER_DESC desc = {};
		desc.ByteWidth = 16 * sizeof(float);
		desc.Usage = D3D10_USAGE_IMMUTABLE;
		desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;

		// Setup orthographic projection matrix
		const float ortho_projection[16] = {
			2.0f / _width, 0.0f,   0.0f, 0.0f,
			0.0f, -2.0f / _height, 0.0f, 0.0f,
			0.0f,          0.0f,   0.5f, 0.0f,
			-1.f,          1.0f,   0.5f, 1.0f
		};

		D3D10_SUBRESOURCE_DATA initial_data = {};
		initial_data.pSysMem = ortho_projection;
		initial_data.SysMemPitch = sizeof(ortho_projection);
		if (FAILED(_device->CreateBuffer(&desc, &initial_data, &_imgui_constant_buffer)))
			return false;
	}

	{   D3D10_BLEND_DESC desc = {};
		desc.BlendEnable[0] = true;
		desc.SrcBlend = D3D10_BLEND_SRC_ALPHA;
		desc.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
		desc.BlendOp = D3D10_BLEND_OP_ADD;
		desc.SrcBlendAlpha = D3D10_BLEND_INV_SRC_ALPHA;
		desc.DestBlendAlpha = D3D10_BLEND_ZERO;
		desc.BlendOpAlpha = D3D10_BLEND_OP_ADD;
		desc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
		if (FAILED(_device->CreateBlendState(&desc, &_imgui_blend_state)))
			return false;
	}

	{   D3D10_RASTERIZER_DESC desc = {};
		desc.FillMode = D3D10_FILL_SOLID;
		desc.CullMode = D3D10_CULL_NONE;
		desc.ScissorEnable = true;
		desc.DepthClipEnable = true;
		if (FAILED(_device->CreateRasterizerState(&desc, &_imgui_rasterizer_state)))
			return false;
	}

	{   D3D10_DEPTH_STENCIL_DESC desc = {};
		desc.DepthEnable = false;
		desc.StencilEnable = false;
		if (FAILED(_device->CreateDepthStencilState(&desc, &_imgui_depthstencil_state)))
			return false;
	}

	{   D3D10_SAMPLER_DESC desc = {};
		desc.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR;
		desc.AddressU = D3D10_TEXTURE_ADDRESS_WRAP;
		desc.AddressV = D3D10_TEXTURE_ADDRESS_WRAP;
		desc.AddressW = D3D10_TEXTURE_ADDRESS_WRAP;
		desc.ComparisonFunc = D3D10_COMPARISON_ALWAYS;
		if (FAILED(_device->CreateSamplerState(&desc, &_imgui_texture_sampler)))
			return false;
	}

	return true;
}

void reshade::d3d10::runtime_d3d10::render_imgui_draw_data(ImDrawData *draw_data)
{
	assert(draw_data->DisplayPos.x == 0 && draw_data->DisplaySize.x == _width);
	assert(draw_data->DisplayPos.y == 0 && draw_data->DisplaySize.y == _height);

	// Create and grow vertex/index buffers if needed
	if (_imgui_index_buffer_size < draw_data->TotalIdxCount)
	{
		_imgui_index_buffer.reset();
		_imgui_index_buffer_size = draw_data->TotalIdxCount + 10000;

		D3D10_BUFFER_DESC desc = {};
		desc.Usage = D3D10_USAGE_DYNAMIC;
		desc.ByteWidth = _imgui_index_buffer_size * sizeof(ImDrawIdx);
		desc.BindFlags = D3D10_BIND_INDEX_BUFFER;
		desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;

		if (FAILED(_device->CreateBuffer(&desc, nullptr, &_imgui_index_buffer)))
			return;
	}
	if (_imgui_vertex_buffer_size < draw_data->TotalVtxCount)
	{
		_imgui_vertex_buffer.reset();
		_imgui_vertex_buffer_size = draw_data->TotalVtxCount + 5000;

		D3D10_BUFFER_DESC desc = {};
		desc.Usage = D3D10_USAGE_DYNAMIC;
		desc.ByteWidth = _imgui_vertex_buffer_size * sizeof(ImDrawVert);
		desc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
		desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
		desc.MiscFlags = 0;

		if (FAILED(_device->CreateBuffer(&desc, nullptr, &_imgui_vertex_buffer)))
			return;
	}

	ImDrawIdx *idx_dst; ImDrawVert *vtx_dst;
	if (FAILED(_imgui_index_buffer->Map(D3D10_MAP_WRITE_DISCARD, 0, reinterpret_cast<void **>(&idx_dst))) ||
		FAILED(_imgui_vertex_buffer->Map(D3D10_MAP_WRITE_DISCARD, 0, reinterpret_cast<void **>(&vtx_dst))))
		return;

	for (int n = 0; n < draw_data->CmdListsCount; n++)
	{
		const ImDrawList *const draw_list = draw_data->CmdLists[n];
		memcpy(idx_dst, draw_list->IdxBuffer.Data, draw_list->IdxBuffer.Size * sizeof(ImDrawIdx));
		memcpy(vtx_dst, draw_list->VtxBuffer.Data, draw_list->VtxBuffer.Size * sizeof(ImDrawVert));
		idx_dst += draw_list->IdxBuffer.Size;
		vtx_dst += draw_list->VtxBuffer.Size;
	}

	_imgui_index_buffer->Unmap();
	_imgui_vertex_buffer->Unmap();

	// Setup render state and render draw lists
	_device->IASetInputLayout(_imgui_input_layout.get());
	_device->IASetIndexBuffer(_imgui_index_buffer.get(), sizeof(ImDrawIdx) == 2 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT, 0);
	const UINT stride = sizeof(ImDrawVert), offset = 0;
	ID3D10Buffer *const vertex_buffers[] = { _imgui_vertex_buffer.get() };
	_device->IASetVertexBuffers(0, ARRAYSIZE(vertex_buffers), vertex_buffers, &stride, &offset);
	_device->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	_device->VSSetShader(_imgui_vertex_shader.get());
	ID3D10Buffer *const constant_buffers[] = { _imgui_constant_buffer.get() };
	_device->VSSetConstantBuffers(0, ARRAYSIZE(constant_buffers), constant_buffers);
	_device->GSSetShader(nullptr);
	_device->PSSetShader(_imgui_pixel_shader.get());
	ID3D10SamplerState *const samplers[] = { _imgui_texture_sampler.get() };
	_device->PSSetSamplers(0, ARRAYSIZE(samplers), samplers);
	_device->RSSetState(_imgui_rasterizer_state.get());
	const D3D10_VIEWPORT viewport = { 0, 0, _width, _height, 0.0f, 1.0f };
	_device->RSSetViewports(1, &viewport);
	const FLOAT blend_factor[4] = { 0.f, 0.f, 0.f, 0.f };
	_device->OMSetBlendState(_imgui_blend_state.get(), blend_factor, D3D10_DEFAULT_SAMPLE_MASK);
	_device->OMSetDepthStencilState(_imgui_depthstencil_state.get(), 0);
	ID3D10RenderTargetView *const render_targets[] = { _backbuffer_rtv[0].get() };
	_device->OMSetRenderTargets(ARRAYSIZE(render_targets), render_targets, nullptr);

	UINT vtx_offset = 0, idx_offset = 0;
	for (int n = 0; n < draw_data->CmdListsCount; n++)
	{
		const ImDrawList *const draw_list = draw_data->CmdLists[n];

		for (const ImDrawCmd &cmd : draw_list->CmdBuffer)
		{
			assert(cmd.UserCallback == nullptr);

			const D3D10_RECT scissor_rect = {
				static_cast<LONG>(cmd.ClipRect.x),
				static_cast<LONG>(cmd.ClipRect.y),
				static_cast<LONG>(cmd.ClipRect.z),
				static_cast<LONG>(cmd.ClipRect.w)
			};
			_device->RSSetScissorRects(1, &scissor_rect);

			ID3D10ShaderResourceView *const texture_view =
				static_cast<const d3d10_tex_data *>(cmd.TextureId)->srv[0].get();
			_device->PSSetShaderResources(0, 1, &texture_view);

			_device->DrawIndexed(cmd.ElemCount, idx_offset, vtx_offset);

			idx_offset += cmd.ElemCount;
		}

		vtx_offset += draw_list->VtxBuffer.size();
	}
}

void reshade::d3d10::runtime_d3d10::draw_debug_menu()
{
	ImGui::Text(""MSAA is %s"", _is_multisampling_enabled ? ""active"" : ""inactive"");
	ImGui::Spacing();

	assert(_current_tracker != nullptr);

#if RESHADE_DX10_CAPTURE_DEPTH_BUFFERS
	if (ImGui::CollapsingHeader(""Depth and Intermediate Buffers"", ImGuiTreeNodeFlags_DefaultOpen))
	{
		bool modified = false;
		modified |= ImGui::Combo(""Depth Texture Format"", &depth_buffer_texture_format, ""All\\0D16\\0D32F\\0D24S8\\0D32FS8\\0"");

		if (modified)
		{
			runtime::save_config();
			_current_tracker->reset();
			create_depthstencil_replacement(nullptr, nullptr);
			return;
		}

		modified |= ImGui::Checkbox(""Copy depth before clearing"", &depth_buffer_before_clear);

		if (depth_buffer_before_clear)
		{
			if (ImGui::Checkbox(""Extended depth buffer detection"", &extended_depth_buffer_detection))
			{
				cleared_depth_buffer_index = 0;
				modified = true;
			}

			_current_tracker->keep_cleared_depth_textures();

			ImGui::Spacing();
			ImGui::TextUnformatted(""Depth Buffers:"");

			unsigned int current_index = 1;

			for (const auto &it : _current_tracker->cleared_depth_textures())
			{
				char label[512] = """";
				sprintf_s(label, ""%s%2u"", (current_index == cleared_depth_buffer_index ? ""> "" : ""  ""), current_index);

				if (bool value = cleared_depth_buffer_index == current_index; ImGui::Checkbox(label, &value))
				{
					cleared_depth_buffer_index = value ? current_index : 0;
					modified = true;
				}

				ImGui::SameLine();

				ImGui::Text(""=> 0x%p | 0x%p | %ux%u"", it.second.src_depthstencil.get(), it.second.src_texture.get(), it.second.src_texture_desc.Width, it.second.src_texture_desc.Height);

				if (it.second.dest_texture != nullptr)
				{
					ImGui::SameLine();

					ImGui::Text(""=> %p"", it.second.dest_texture.get());
				}

				current_index++;
			}
		}
		else if (!_current_tracker->depth_buffer_counters().empty())
		{
			ImGui::Spacing();
			ImGui::TextUnformatted(""Depth Buffers: (intermediate buffer draw calls in parentheses)"");

			for (const auto &[depthstencil, snapshot] : _current_tracker->depth_buffer_counters())
			{
				char label[512] = """";
				sprintf_s(label, ""%s0x%p"", (depthstencil == _depthstencil ? ""> "" : ""  ""), depthstencil.get());

				if (bool value = _best_depth_stencil_overwrite == depthstencil; ImGui::Checkbox(label, &value))
				{
					_best_depth_stencil_overwrite = value ? depthstencil.get() : nullptr;

					com_ptr<ID3D10Texture2D> texture = snapshot.texture;

					if (texture == nullptr && _best_depth_stencil_overwrite != nullptr)
					{
						com_ptr<ID3D10Resource> resource;
						_best_depth_stencil_overwrite->GetResource(&resource);

						resource->QueryInterface(&texture);
					}

					create_depthstencil_replacement(_best_depth_stencil_overwrite, texture.get());
				}

				ImGui::SameLine();

				std::string additional_view_label;

				if (!snapshot.additional_views.empty())
				{
					additional_view_label += '(';

					for (auto const &[view, stats] : snapshot.additional_views)
						additional_view_label += std::to_string(stats.drawcalls) + "", "";

					// Remove last "", "" from string
					additional_view_label.pop_back();
					additional_view_label.pop_back();

					additional_view_label += ')';
				}

				ImGui::Text(""| %5u draw calls ==> %8u vertices, %2u additional render target%c %s"", snapshot.stats.drawcalls, snapshot.stats.vertices, snapshot.additional_views.size(), snapshot.additional_views.size() != 1 ? 's' : ' ', additional_view_label.c_str());
			}
		}

		if (modified)
		{
			runtime::save_config();
		}
	}
#endif
#if RESHADE_DX10_CAPTURE_CONSTANT_BUFFERS
	if (ImGui::CollapsingHeader(""Constant Buffers"", ImGuiTreeNodeFlags_DefaultOpen))
	{
		for (const auto &[buffer, counter] : _current_tracker.constant_buffer_counters())
		{
			bool likely_camera_transform_buffer = false;

			D3D10_BUFFER_DESC desc;
			buffer->GetDesc(&desc);

			if (counter.ps_uses > 0 && counter.vs_uses > 0 && counter.mapped < .10 * counter.vs_uses && desc.ByteWidth > 1000)
				likely_camera_transform_buffer = true;

			ImGui::Text(""%s 0x%p | used in %4u vertex shaders and %4u pixel shaders, mapped %3u times, %8u bytes"", likely_camera_transform_buffer ? "">"" : "" "", buffer.get(), counter.vs_uses, counter.ps_uses, counter.mapped, desc.ByteWidth);
		}
	}
#endif
}
#endif

#if RESHADE_DX10_CAPTURE_DEPTH_BUFFERS
void reshade::d3d10::runtime_d3d10::detect_depth_source(draw_call_tracker &tracker)
{
	if (depth_buffer_before_clear)
		_best_depth_stencil_overwrite = nullptr;

	if (_is_multisampling_enabled || _best_depth_stencil_overwrite != nullptr || (_framecount % 30 && !depth_buffer_before_clear))
		return;

	if (_has_high_network_activity)
	{
		create_depthstencil_replacement(nullptr, nullptr);
		return;
	}

	if (depth_buffer_before_clear)
	{
		// At the final rendering stage, it is fine to rely on the depth stencil to select the best depth texture
		// But when we retrieve the depth textures before the final rendering stage, there is chance that one or many different depth textures are associated to the same depth stencil (for instance, in Bioshock 2)
		// In this case, we cannot use the depth stencil to determine which depth texture is the good one, so we can use the default depth stencil
		// For the moment, the best we can do is retrieve all the depth textures that has been cleared in the rendering pipeline, then select one of them (by default, the last one)
		// In the future, maybe we could find a way to retrieve depth texture statistics (number of draw calls and number of vertices), so ReShade could automatically select the best one
		ID3D10Texture2D *const best_match_texture = tracker.find_best_cleared_depth_buffer_texture(cleared_depth_buffer_index);
		if (best_match_texture != nullptr)
			create_depthstencil_replacement(_default_depthstencil.get(), best_match_texture);
		return;
	}

	const auto best_snapshot = tracker.find_best_snapshot(_width, _height);
	if (best_snapshot.depthstencil != nullptr)
		create_depthstencil_replacement(best_snapshot.depthstencil, best_snapshot.texture.get());
}

bool reshade::d3d10::runtime_d3d10::create_depthstencil_replacement(ID3D10DepthStencilView *depthstencil, ID3D10Texture2D *texture)
{
	_depthstencil.reset();
	_depthstencil_replacement.reset();
	_depthstencil_texture.reset();
	_depthstencil_texture_srv.reset();

	if (depthstencil != nullptr)
	{
		assert(texture != nullptr);
		_depthstencil = depthstencil;
		_depthstencil_texture = texture;

		D3D10_TEXTURE2D_DESC tex_desc;
		_depthstencil_texture->GetDesc(&tex_desc);

		HRESULT hr = S_OK;

		if ((tex_desc.BindFlags & D3D10_BIND_SHADER_RESOURCE) == 0)
		{
			_depthstencil_texture.reset();

			tex_desc.Format = make_dxgi_format_typeless(tex_desc.Format);
			tex_desc.BindFlags = D3D10_BIND_DEPTH_STENCIL | D3D10_BIND_SHADER_RESOURCE;

			hr = _device->CreateTexture2D(&tex_desc, nullptr, &_depthstencil_texture);

			if (SUCCEEDED(hr))
			{
				D3D10_DEPTH_STENCIL_VIEW_DESC dsv_desc = {};
				dsv_desc.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
				dsv_desc.Format = make_dxgi_format_dsv(tex_desc.Format);

				hr = _device->CreateDepthStencilView(_depthstencil_texture.get(), &dsv_desc, &_depthstencil_replacement);
			}
		}

		if (FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create depth stencil replacement texture! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}

		D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
		srv_desc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
		srv_desc.Texture2D.MipLevels = 1;
		srv_desc.Format = make_dxgi_format_normal(tex_desc.Format);

		if (hr = _device->CreateShaderResourceView(_depthstencil_texture.get(), &srv_desc, &_depthstencil_texture_srv); FAILED(hr))
		{
			LOG(ERROR) << ""Failed to create depth stencil replacement resource view! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
			return false;
		}

		// Update auto depth stencil
		com_ptr<ID3D10DepthStencilView> current_depthstencil;
		com_ptr<ID3D10RenderTargetView> targets[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT];
		_device->OMGetRenderTargets(D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT, reinterpret_cast<ID3D10RenderTargetView **>(targets), &current_depthstencil);
		if (current_depthstencil != nullptr && current_depthstencil == _depthstencil)
			_device->OMSetRenderTargets(D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT, reinterpret_cast<ID3D10RenderTargetView *const *>(targets), _depthstencil_replacement.get());
	}

	update_texture_references(texture_reference::depth_buffer);

	return true;
}

com_ptr<ID3D10Texture2D> reshade::d3d10::runtime_d3d10::select_depth_texture_save(D3D10_TEXTURE2D_DESC &texture_desc)
{
	// Function that selects the appropriate texture where we want to save the depth texture before it is cleared
	// If this texture is null, create it according to the dimensions and the format of the depth texture
	// Doing so, we avoid to create a new texture each time the depth texture is saved

	texture_desc.Format = make_dxgi_format_typeless(texture_desc.Format);

	// Create an unique index based on the texture format and dimensions
	UINT idx = texture_desc.Format * texture_desc.Width * texture_desc.Height;

	if (const auto it = _depth_texture_saves.find(idx); it != _depth_texture_saves.end())
		return it->second;

	texture_desc.BindFlags = D3D10_BIND_DEPTH_STENCIL | D3D10_BIND_SHADER_RESOURCE;

	// Create the saved texture pointed by the index if it does not already exist
	com_ptr<ID3D10Texture2D> depth_texture_save;

	HRESULT hr = _device->CreateTexture2D(&texture_desc, nullptr, &depth_texture_save);

	if (FAILED(hr))
	{
		LOG(ERROR) << ""Failed to create depth texture copy! HRESULT is '"" << std::hex << hr << std::dec << ""'."";
		return nullptr;
	}

	_depth_texture_saves.emplace(idx, depth_texture_save);

	return depth_texture_save;
}
#endif
",16272,True,3127.568708062846,median
"CLASS zcl_abapgit_file_status DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    CLASS-METHODS status
      IMPORTING
        !io_repo          TYPE REF TO zcl_abapgit_repo
        !ii_log           TYPE REF TO zif_abapgit_log OPTIONAL
      RETURNING
        VALUE(rt_results) TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS identify_object
      IMPORTING
        !iv_filename TYPE string
        !iv_path     TYPE string
        !iv_devclass TYPE devclass OPTIONAL
        !io_dot      TYPE REF TO zcl_abapgit_dot_abapgit
      EXPORTING
        !es_item     TYPE zif_abapgit_definitions=>ty_item
        !ev_is_xml   TYPE abap_bool
      RAISING
        zcx_abapgit_exception .
  PROTECTED SECTION.
  PRIVATE SECTION.

    CLASS-METHODS calculate_status
      IMPORTING
        !iv_devclass      TYPE devclass
        !io_dot           TYPE REF TO zcl_abapgit_dot_abapgit
        !it_local         TYPE zif_abapgit_definitions=>ty_files_item_tt
        !it_remote        TYPE zif_abapgit_definitions=>ty_files_tt
        !it_cur_state     TYPE zif_abapgit_definitions=>ty_file_signatures_tt
      RETURNING
        VALUE(rt_results) TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS run_checks
      IMPORTING
        !ii_log     TYPE REF TO zif_abapgit_log
        !it_results TYPE zif_abapgit_definitions=>ty_results_tt
        !io_dot     TYPE REF TO zcl_abapgit_dot_abapgit
        !iv_top     TYPE devclass
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS build_existing
      IMPORTING
        !is_local        TYPE zif_abapgit_definitions=>ty_file_item
        !is_remote       TYPE zif_abapgit_definitions=>ty_file
        !it_state        TYPE zif_abapgit_definitions=>ty_file_signatures_ts
      RETURNING
        VALUE(rs_result) TYPE zif_abapgit_definitions=>ty_result .
    CLASS-METHODS build_new_local
      IMPORTING
        !is_local        TYPE zif_abapgit_definitions=>ty_file_item
      RETURNING
        VALUE(rs_result) TYPE zif_abapgit_definitions=>ty_result .
    CLASS-METHODS build_new_remote
      IMPORTING
        !iv_devclass     TYPE devclass
        !io_dot          TYPE REF TO zcl_abapgit_dot_abapgit
        !is_remote       TYPE zif_abapgit_definitions=>ty_file
        !it_items        TYPE zif_abapgit_definitions=>ty_items_ts
        !it_state        TYPE zif_abapgit_definitions=>ty_file_signatures_ts
      RETURNING
        VALUE(rs_result) TYPE zif_abapgit_definitions=>ty_result
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS get_object_package
      IMPORTING
        !iv_object         TYPE tadir-object
        !iv_obj_name       TYPE tadir-obj_name
      RETURNING
        VALUE(rv_devclass) TYPE devclass
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_package_move
      IMPORTING
        !ii_log     TYPE REF TO zif_abapgit_log
        !it_results TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_files_folder
      IMPORTING
        !ii_log     TYPE REF TO zif_abapgit_log
        !it_results TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_package_folder
      IMPORTING
        !ii_log     TYPE REF TO zif_abapgit_log
        !it_results TYPE zif_abapgit_definitions=>ty_results_tt
        !io_dot     TYPE REF TO zcl_abapgit_dot_abapgit
        !iv_top     TYPE devclass
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_multiple_files
      IMPORTING
        !ii_log     TYPE REF TO zif_abapgit_log
        !it_results TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_namespace
      IMPORTING
        !ii_log     TYPE REF TO zif_abapgit_log
        !it_results TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
ENDCLASS.



CLASS zcl_abapgit_file_status IMPLEMENTATION.


  METHOD build_existing.

    DATA: ls_file_sig LIKE LINE OF it_state.

    "" Item
    rs_result-obj_type = is_local-item-obj_type.
    rs_result-obj_name = is_local-item-obj_name.
    rs_result-package  = is_local-item-devclass.

    "" File
    rs_result-path     = is_local-file-path.
    rs_result-filename = is_local-file-filename.

    IF is_local-file-sha1 = is_remote-sha1.
      rs_result-match = abap_true.
      RETURN.
    ENDIF.

    "" Match against current state
    READ TABLE it_state INTO ls_file_sig
      WITH KEY path = is_local-file-path
      filename = is_local-file-filename
      BINARY SEARCH.

    IF sy-subrc = 0.
      IF ls_file_sig-sha1 <> is_local-file-sha1.
        rs_result-lstate = zif_abapgit_definitions=>c_state-modified.
      ENDIF.
      IF ls_file_sig-sha1 <> is_remote-sha1.
        rs_result-rstate = zif_abapgit_definitions=>c_state-modified.
      ENDIF.
      rs_result-match = boolc( rs_result-lstate IS INITIAL
        AND rs_result-rstate IS INITIAL ).
    ELSE.
      "" This is a strange situation. As both local and remote exist
      "" the state should also be present. Maybe this is a first run of the code.
      "" In this case just compare hashes directly and mark both changed
      "" the user will presumably decide what to do after checking the actual diff
      rs_result-match = boolc( is_local-file-sha1 = is_remote-sha1 ).
      IF rs_result-match = abap_false.
        rs_result-lstate = zif_abapgit_definitions=>c_state-modified.
        rs_result-rstate = zif_abapgit_definitions=>c_state-modified.
      ENDIF.
    ENDIF.

  ENDMETHOD.


  METHOD build_new_local.

    "" Item
    rs_result-obj_type = is_local-item-obj_type.
    rs_result-obj_name = is_local-item-obj_name.
    rs_result-package  = is_local-item-devclass.

    "" File
    rs_result-path     = is_local-file-path.
    rs_result-filename = is_local-file-filename.

    "" Match
    rs_result-match    = abap_false.
    rs_result-lstate   = zif_abapgit_definitions=>c_state-added.

  ENDMETHOD.


  METHOD build_new_remote.

    DATA: ls_item     LIKE LINE OF it_items,
          ls_file_sig LIKE LINE OF it_state.

    "" Common and default part
    rs_result-path     = is_remote-path.
    rs_result-filename = is_remote-filename.
    rs_result-match    = abap_false.
    rs_result-rstate   = zif_abapgit_definitions=>c_state-added.

    identify_object( EXPORTING iv_filename = is_remote-filename
                               iv_path     = is_remote-path
                               iv_devclass = iv_devclass
                               io_dot      = io_dot
                     IMPORTING es_item     = ls_item ).

    "" Check if in item index + get package
    READ TABLE it_items INTO ls_item
      WITH KEY obj_type = ls_item-obj_type obj_name = ls_item-obj_name
      BINARY SEARCH.

    IF sy-subrc = 0.

      "" Completely new (xml, abap) and new file in an existing object
      rs_result-obj_type = ls_item-obj_type.
      rs_result-obj_name = ls_item-obj_name.
      rs_result-package  = ls_item-devclass.

      READ TABLE it_state INTO ls_file_sig
        WITH KEY path = is_remote-path filename = is_remote-filename
        BINARY SEARCH.

      "" Existing file but from another package
      "" was not added during local file proc as was not in tadir for repo package
      IF sy-subrc = 0.
        IF ls_file_sig-sha1 = is_remote-sha1.
          rs_result-match = abap_true.
          CLEAR rs_result-rstate.
        ELSE.
          rs_result-rstate = zif_abapgit_definitions=>c_state-modified.
        ENDIF.

        "" Item is in state and in cache but with no package - it was deleted
        "" OR devclass is the same as repo package (see #532)
        IF ls_item-devclass IS INITIAL OR ls_item-devclass = iv_devclass.
          rs_result-match  = abap_false.
          rs_result-lstate = zif_abapgit_definitions=>c_state-deleted.
        ENDIF.
      ENDIF.

    ELSE. "" Completely unknown file, probably non-abapgit
      ASSERT 1 = 1. "" No action, just follow defaults
    ENDIF.

  ENDMETHOD.


  METHOD calculate_status.

    DATA: lt_remote       LIKE it_remote,
          lv_index        TYPE i,
          lt_items        TYPE zif_abapgit_definitions=>ty_items_tt,
          ls_item         LIKE LINE OF lt_items,
          lv_is_xml       TYPE abap_bool,
          lv_sub_fetched  TYPE abap_bool,
          lt_sub_packages TYPE zif_abapgit_sap_package=>ty_devclass_tt,
          lv_msg          TYPE string,
          lt_items_idx    TYPE zif_abapgit_definitions=>ty_items_ts,
          lt_state_idx    TYPE zif_abapgit_definitions=>ty_file_signatures_ts. "" Sorted by path+filename

    FIELD-SYMBOLS: <ls_remote> LIKE LINE OF it_remote,
                   <ls_result> LIKE LINE OF rt_results,
                   <ls_state>  LIKE LINE OF it_cur_state,
                   <ls_local>  LIKE LINE OF it_local.


    lt_state_idx = it_cur_state. "" Force sort it
    lt_remote    = it_remote.
    SORT lt_remote BY path filename.

    "" Skip ignored files
    LOOP AT lt_remote ASSIGNING <ls_remote>.
      lv_index = sy-tabix.
      IF io_dot->is_ignored( iv_path     = <ls_remote>-path
                             iv_filename = <ls_remote>-filename ) = abap_true.
        DELETE lt_remote INDEX lv_index.
      ENDIF.
    ENDLOOP.

    "" Process local files and new local files
    LOOP AT it_local ASSIGNING <ls_local>.
      "" Skip ignored files
      IF io_dot->is_ignored( iv_path     = <ls_local>-file-path
                             iv_filename = <ls_local>-file-filename ) = abap_true.
        CONTINUE.
      ENDIF.

      APPEND INITIAL LINE TO rt_results ASSIGNING <ls_result>.
      IF <ls_local>-item IS NOT INITIAL.
        APPEND <ls_local>-item TO lt_items. "" Collect for item index
      ENDIF.

      READ TABLE lt_remote ASSIGNING <ls_remote>
        WITH KEY path = <ls_local>-file-path filename = <ls_local>-file-filename
        BINARY SEARCH.
      IF sy-subrc = 0.  "" Exist local and remote
        <ls_result> = build_existing(
          is_local  = <ls_local>
          is_remote = <ls_remote>
          it_state  = lt_state_idx ).
        ASSERT <ls_remote>-sha1 IS NOT INITIAL.
        CLEAR <ls_remote>-sha1. "" Mark as processed
      ELSE.             "" Only L exists
        <ls_result> = build_new_local( <ls_local> ).
        "" Check if same file exists in different location
        READ TABLE lt_remote ASSIGNING <ls_remote>
          WITH KEY filename = <ls_local>-file-filename.
        IF sy-subrc = 0 AND <ls_local>-file-sha1 = <ls_remote>-sha1.
          <ls_result>-packmove = abap_true.
        ELSEIF sy-subrc = 4.
          "" Check if file existed before and was deleted remotely
          READ TABLE lt_state_idx ASSIGNING <ls_state>
            WITH KEY path = <ls_local>-file-path filename = <ls_local>-file-filename
            BINARY SEARCH.
          IF sy-subrc = 0.
            IF <ls_local>-file-sha1 = <ls_state>-sha1.
              <ls_result>-lstate = zif_abapgit_definitions=>c_state-unchanged.
            ELSE.
              <ls_result>-lstate = zif_abapgit_definitions=>c_state-modified.
            ENDIF.
            <ls_result>-rstate = zif_abapgit_definitions=>c_state-deleted.
          ENDIF.
        ENDIF.
      ENDIF.
      <ls_result>-inactive = <ls_local>-item-inactive.
    ENDLOOP.

    "" Complete item index for unmarked remote files
    LOOP AT lt_remote ASSIGNING <ls_remote> WHERE sha1 IS NOT INITIAL.
      identify_object( EXPORTING iv_filename = <ls_remote>-filename
                                 iv_path     = <ls_remote>-path
                                 io_dot      = io_dot
                                 iv_devclass = iv_devclass
                       IMPORTING es_item     = ls_item
                                 ev_is_xml   = lv_is_xml ).

      CHECK lv_is_xml = abap_true. "" only object definitions

      ls_item-devclass = get_object_package(
        iv_object   = ls_item-obj_type
        iv_obj_name = ls_item-obj_name ).

      IF NOT ls_item-devclass IS INITIAL AND iv_devclass <> ls_item-devclass.
        IF lv_sub_fetched = abap_false.
          lt_sub_packages = zcl_abapgit_factory=>get_sap_package( iv_devclass )->list_subpackages( ).
          lv_sub_fetched = abap_true.
          SORT lt_sub_packages BY table_line. ""Optimize Read Access
        ENDIF.
        "" Make sure the package is under the repo main package
        READ TABLE lt_sub_packages TRANSPORTING NO FIELDS
          WITH KEY table_line = ls_item-devclass
          BINARY SEARCH.
        IF sy-subrc <> 0.
          IF ls_item-obj_type = 'DEVC'.
            "" If package already exist but is not included in the package hierarchy of
            "" the package assigned to the repository, then a manual change of the package
            "" is required i.e. setting a parent package to iv_devclass (or one of its
            "" subpackages). We don't this automatically since it's not clear where in the
            "" hierarchy the new package should be located. (#4108)
            lv_msg = |Package { ls_item-devclass } is not a subpackage of { iv_devclass
                     }. Assign { ls_item-devclass } to package hierarchy of { iv_devclass
                     } and repeat process.|.
            zcx_abapgit_exception=>raise( lv_msg ).
          ELSE.
            CLEAR ls_item-devclass.
          ENDIF.
        ENDIF.
      ENDIF.

      APPEND ls_item TO lt_items.
    ENDLOOP.

    SORT lt_items DESCENDING. "" Default key - type, name, pkg, inactive
    DELETE ADJACENT DUPLICATES FROM lt_items COMPARING obj_type obj_name devclass.
    lt_items_idx = lt_items. "" Self protection + UNIQUE records assertion

    "" Process new remote files (marked above with empty SHA1)
    LOOP AT lt_remote ASSIGNING <ls_remote> WHERE sha1 IS NOT INITIAL.
      APPEND INITIAL LINE TO rt_results ASSIGNING <ls_result>.
      <ls_result> = build_new_remote( iv_devclass = iv_devclass
                                      io_dot      = io_dot
                                      is_remote   = <ls_remote>
                                      it_items    = lt_items_idx
                                      it_state    = lt_state_idx ).
      "" Check if same file exists in different location
      READ TABLE it_local ASSIGNING <ls_local>
        WITH KEY file-filename = <ls_remote>-filename.
      IF sy-subrc = 0.
        <ls_result>-match = abap_false.
        <ls_result>-lstate = zif_abapgit_definitions=>c_state-deleted.
        <ls_result>-rstate = zif_abapgit_definitions=>c_state-unchanged.
        IF <ls_local>-file-sha1 = <ls_remote>-sha1.
          <ls_result>-packmove = abap_true.
        ENDIF.
      ELSEIF sy-subrc = 4.
        "" Check if file existed before and was deleted locally
        READ TABLE lt_state_idx ASSIGNING <ls_state>
          WITH KEY path = <ls_remote>-path filename = <ls_remote>-filename
          BINARY SEARCH.
        IF sy-subrc = 0.
          <ls_result>-lstate = zif_abapgit_definitions=>c_state-deleted.
        ENDIF.
      ENDIF.
    ENDLOOP.

    SORT rt_results BY
      obj_type ASCENDING
      obj_name ASCENDING
      filename ASCENDING
      path ASCENDING.

  ENDMETHOD.


  METHOD check_files_folder.

    DATA:
      ls_item     TYPE zif_abapgit_definitions=>ty_item,
      lt_res_sort LIKE it_results,
      lt_item_idx LIKE it_results.

    FIELD-SYMBOLS:
      <ls_result>     LIKE LINE OF it_results,
      <ls_result_idx> LIKE LINE OF it_results.

    "" Collect object index
    lt_res_sort = it_results.
    SORT lt_res_sort BY obj_type ASCENDING obj_name ASCENDING.

    LOOP AT it_results ASSIGNING <ls_result> WHERE NOT obj_type IS INITIAL AND packmove = abap_false.

      IF NOT ( <ls_result>-obj_type = ls_item-obj_type
          AND <ls_result>-obj_name = ls_item-obj_name ).
        APPEND INITIAL LINE TO lt_item_idx ASSIGNING <ls_result_idx>.
        <ls_result_idx>-obj_type = <ls_result>-obj_type.
        <ls_result_idx>-obj_name = <ls_result>-obj_name.
        <ls_result_idx>-path     = <ls_result>-path.
        MOVE-CORRESPONDING <ls_result> TO ls_item.
      ENDIF.

    ENDLOOP.

    LOOP AT it_results ASSIGNING <ls_result>
      WHERE NOT obj_type IS INITIAL AND obj_type <> 'DEVC' AND packmove = abap_false.

      READ TABLE lt_item_idx ASSIGNING <ls_result_idx>
        WITH KEY obj_type = <ls_result>-obj_type obj_name = <ls_result>-obj_name
        BINARY SEARCH. "" Sorted above

      IF sy-subrc <> 0 OR <ls_result>-path <> <ls_result_idx>-path. "" All paths are same
        ii_log->add( iv_msg = |Files for object { <ls_result>-obj_type } {
                              <ls_result>-obj_name } are not placed in the same folder|
                     iv_type = 'W'
                     iv_rc   = '1' ).
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD check_multiple_files.

    DATA:
      lt_res_sort LIKE it_results,
      ls_file     TYPE zif_abapgit_definitions=>ty_file_signature.

    FIELD-SYMBOLS <ls_result> LIKE LINE OF it_results.

    lt_res_sort = it_results.
    SORT lt_res_sort BY filename ASCENDING.

    LOOP AT lt_res_sort ASSIGNING <ls_result> WHERE obj_type <> 'DEVC' AND packmove = abap_false.
      IF <ls_result>-filename IS NOT INITIAL AND <ls_result>-filename = ls_file-filename.
        ii_log->add( iv_msg  = |Multiple files with same filename, { <ls_result>-filename }|
                     iv_type = 'W'
                     iv_rc   = '3' ).
      ENDIF.

      IF <ls_result>-filename IS INITIAL.
        ii_log->add( iv_msg  = |Filename is empty for object { <ls_result>-obj_type } { <ls_result>-obj_name }|
                     iv_type = 'W'
                     iv_rc   = '4' ).
      ENDIF.

      MOVE-CORRESPONDING <ls_result> TO ls_file.
    ENDLOOP.

  ENDMETHOD.


  METHOD check_namespace.

    DATA:
      lv_namespace TYPE namespace,
      lt_namespace TYPE TABLE OF namespace.

    FIELD-SYMBOLS <ls_result> LIKE LINE OF it_results.

    "" Collect all namespaces based on name of xml-files
    LOOP AT it_results ASSIGNING <ls_result>.
      FIND REGEX '#(.*)#.*\\..*\\.xml' IN <ls_result>-filename SUBMATCHES lv_namespace.
      IF sy-subrc = 0.
        lv_namespace = '/' && to_upper( lv_namespace ) && '/'.
        COLLECT lv_namespace INTO lt_namespace.
      ENDIF.
    ENDLOOP.

    LOOP AT lt_namespace INTO lv_namespace.
      CALL FUNCTION 'TR_CHECK_NAMESPACE'
        EXPORTING
          iv_namespace        = lv_namespace
        EXCEPTIONS
          namespace_not_valid = 1
          OTHERS              = 2.
      IF sy-subrc <> 0.
        ii_log->add( iv_msg  = |Namespace { lv_namespace } does not exist. Create it in transaction SE03|
                     iv_type = 'W'
                     iv_rc   = '6' ).
      ENDIF.
    ENDLOOP.

  ENDMETHOD.


  METHOD check_package_folder.

    DATA:
      lv_path         TYPE string,
      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>
      WHERE NOT package IS INITIAL AND NOT path IS INITIAL AND packmove = abap_false.

      lv_path = lo_folder_logic->package_to_path(
        iv_top     = iv_top
        io_dot     = io_dot
        iv_package = <ls_result>-package ).

      IF lv_path <> <ls_result>-path.
        ii_log->add( iv_msg = |Package and path does not match for object, {
                       <ls_result>-obj_type } { <ls_result>-obj_name }|
                     iv_type = 'W'
                     iv_rc   = '2' ).
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD check_package_move.

    DATA:
      lt_move_idx LIKE it_results.

    FIELD-SYMBOLS:
      <ls_result>      LIKE LINE OF it_results,
      <ls_result_move> LIKE LINE OF it_results.

    LOOP AT it_results ASSIGNING <ls_result>
      WHERE lstate = zif_abapgit_definitions=>c_state-added AND packmove = abap_true.

      READ TABLE lt_move_idx TRANSPORTING NO FIELDS
        WITH KEY obj_type = <ls_result>-obj_type obj_name = <ls_result>-obj_name
        BINARY SEARCH. "" Sorted since it_result is sorted
      IF sy-subrc <> 0.
        ii_log->add( iv_msg  = |Changed package assignment for object {
                               <ls_result>-obj_type } { <ls_result>-obj_name }|
                     iv_type = 'W'
                     iv_rc   = '5' ).
        APPEND INITIAL LINE TO lt_move_idx ASSIGNING <ls_result_move>.
        <ls_result_move>-obj_type = <ls_result>-obj_type.
        <ls_result_move>-obj_name = <ls_result>-obj_name.
        <ls_result_move>-path     = <ls_result>-path.
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD get_object_package.
    DATA: lv_name    TYPE devclass,
          li_package TYPE REF TO zif_abapgit_sap_package.

    rv_devclass = zcl_abapgit_factory=>get_tadir( )->get_object_package(
      iv_object   = iv_object
      iv_obj_name = iv_obj_name ).
    IF rv_devclass IS INITIAL AND iv_object = 'DEVC' AND iv_obj_name(1) = '$'.
      "" local packages usually have no tadir entry
      lv_name = iv_obj_name.
      li_package = zcl_abapgit_factory=>get_sap_package( lv_name ).
      IF li_package->exists( ) = abap_true.
        rv_devclass = lv_name.
      ENDIF.
    ENDIF.
  ENDMETHOD.


  METHOD identify_object.

    DATA: lv_name TYPE string,
          lv_type TYPE string,
          lv_ext  TYPE string.

    "" Guess object type and name
    SPLIT to_upper( iv_filename ) AT '.' INTO lv_name lv_type lv_ext.

    "" Handle namespaces
    REPLACE ALL OCCURRENCES OF '#' IN lv_name WITH '/'.
    REPLACE ALL OCCURRENCES OF '#' IN lv_type WITH '/'.
    REPLACE ALL OCCURRENCES OF '#' IN lv_ext WITH '/'.

    "" The counter part to this logic must be maintained in ZCL_ABAPGIT_OBJECTS_FILES->FILENAME
    IF lv_type = 'DEVC'.
      "" Try to get a unique package name for DEVC by using the path
      ASSERT lv_name = 'PACKAGE'.
      lv_name = zcl_abapgit_folder_logic=>get_instance( )->path_to_package(
        iv_top                  = iv_devclass
        io_dot                  = io_dot
        iv_create_if_not_exists = abap_false
        iv_path                 = iv_path ).
    ELSE.
      "" Get original object name
      lv_name = cl_http_utility=>unescape_url( lv_name ).
    ENDIF.

    CLEAR es_item.
    es_item-obj_type = lv_type.
    es_item-obj_name = lv_name.
    ev_is_xml        = boolc( lv_ext = 'XML' AND strlen( lv_type ) = 4 ).

  ENDMETHOD.


  METHOD run_checks.

    "" This method just adds messages to the log. No log, nothing to do here
    IF ii_log IS INITIAL.
      RETURN.
    ENDIF.

    "" Find all objects which were assigned to a different package
    check_package_move(
      ii_log     = ii_log
      it_results = it_results ).

    "" Check files for one object is in the same folder
    check_files_folder(
      ii_log     = ii_log
      it_results = it_results ).

    "" Check that objects are created in package corresponding to folder
    check_package_folder(
      ii_log     = ii_log
      it_results = it_results
      io_dot     = io_dot
      iv_top     = iv_top ).

    "" Check for multiple files with same filename
    check_multiple_files(
      ii_log     = ii_log
      it_results = it_results ).

    "" Check if namespaces exist already
    check_namespace(
      ii_log     = ii_log
      it_results = it_results ).

  ENDMETHOD.


  METHOD status.

    DATA lt_local TYPE zif_abapgit_definitions=>ty_files_item_tt.

    lt_local = io_repo->get_files_local( ii_log ).

    IF lines( lt_local ) <= 2.
      "" Less equal two means that we have only the .abapgit.xml and the package in
      "" our local repository. In this case we have to update our local .abapgit.xml
      "" from the remote one. Otherwise we get errors when e.g. the folder starting
      "" folder is different.
      io_repo->find_remote_dot_abapgit( ).
    ENDIF.

    rt_results = calculate_status(
      iv_devclass  = io_repo->get_package( )
      io_dot       = io_repo->get_dot_abapgit( )
      it_local     = io_repo->get_files_local( ii_log )
      it_remote    = io_repo->get_files_remote( )
      it_cur_state = io_repo->get_local_checksums_per_file( ) ).

    run_checks(
      ii_log     = ii_log
      it_results = rt_results
      io_dot     = io_repo->get_dot_abapgit( )
      iv_top     = io_repo->get_package( ) ).

  ENDMETHOD.
ENDCLASS.
",6098,False,1299.6994621745803,median
"// Copyright (c) 2009-2019 The Wazzle Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>
#include <core_io.h>
#include <interfaces/chain.h>
#include <key_io.h>
#include <merkleblock.h>
#include <rpc/server.h>
#include <rpc/util.h>
#include <script/descriptor.h>
#include <script/script.h>
#include <script/standard.h>
#include <sync.h>
#include <util/bip32.h>
#include <util/system.h>
#include <util/time.h>
#include <util/translation.h>
#include <wallet/rpcwallet.h>
#include <wallet/wallet.h>

#include <stdint.h>
#include <tuple>

#include <boost/algorithm/string.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

#include <univalue.h>


int64_t static DecodeDumpTime(const std::string &str) {
    static const boost::posix_time::ptime epoch = boost::posix_time::from_time_t(0);
    static const std::locale loc(std::locale::classic(),
        new boost::posix_time::time_input_facet(""%Y-%m-%dT%H:%M:%SZ""));
    std::istringstream iss(str);
    iss.imbue(loc);
    boost::posix_time::ptime ptime(boost::date_time::not_a_date_time);
    iss >> ptime;
    if (ptime.is_not_a_date_time())
        return 0;
    return (ptime - epoch).total_seconds();
}

std::string static EncodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (const unsigned char c : str) {
        if (c <= 32 || c >= 128 || c == '%') {
            ret << '%' << HexStr(&c, &c + 1);
        } else {
            ret << c;
        }
    }
    return ret.str();
}

static std::string DecodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (unsigned int pos = 0; pos < str.length(); pos++) {
        unsigned char c = str[pos];
        if (c == '%' && pos+2 < str.length()) {
            c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
                ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
            pos += 2;
        }
        ret << c;
    }
    return ret.str();
}

static bool GetWalletAddressesForKey(CWallet* const pwallet, const CKeyID& keyid, std::string& strAddr, std::string& strLabel) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    bool fLabelFound = false;
    CKey key;
    pwallet->GetKey(keyid, key);
    for (const auto& dest : GetAllDestinationsForKey(key.GetPubKey())) {
        if (pwallet->mapAddressBook.count(dest)) {
            if (!strAddr.empty()) {
                strAddr += "","";
            }
            strAddr += EncodeDestination(dest);
            strLabel = EncodeDumpString(pwallet->mapAddressBook[dest].name);
            fLabelFound = true;
        }
    }
    if (!fLabelFound) {
        strAddr = EncodeDestination(GetDestinationForKey(key.GetPubKey(), pwallet->m_default_address_type));
    }
    return fLabelFound;
}

static const int64_t TIMESTAMP_MIN = 0;

static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver, int64_t time_begin = TIMESTAMP_MIN, bool update = true)
{
    int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
    if (wallet.IsAbortingRescan()) {
        throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
    } else if (scanned_time > time_begin) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan was unable to fully rescan the blockchain. Some transactions may be missing."");
    }
}

UniValue importprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprivkey"",
                ""\\nAdds a private key (as returned by dumpprivkey) to your wallet. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one private key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""privkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The private key (see dumpprivkey)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""current label if address exists, otherwise \\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nDump a private key\\n""
            + HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""") +
            ""\\nImport the private key with rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nImport using a label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""testing\\"" false"") +
            ""\\nImport using default blank label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importprivkey"", ""\\""mykey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
    }

    WalletRescanReserver reserver(pwallet);
    bool fRescan = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        std::string strSecret = request.params[0].get_str();
        std::string strLabel = """";
        if (!request.params[1].isNull())
            strLabel = request.params[1].get_str();

        // Whether to perform rescan after import
        if (!request.params[2].isNull())
            fRescan = request.params[2].get_bool();

        if (fRescan && pwallet->chain().havePruned()) {
            // Exit early and print an error.
            // If a block is pruned after this check, we will import the key(s),
            // but fail the rescan with a generic error.
            throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
        }

        if (fRescan && !reserver.reserve()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
        }

        CKey key = DecodeSecret(strSecret);
        if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");

        CPubKey pubkey = key.GetPubKey();
        assert(key.VerifyPubKey(pubkey));
        CKeyID vchAddress = pubkey.GetID();
        {
            pwallet->MarkDirty();

            // We don't know which corresponding address will be used;
            // label all new addresses, and label existing addresses if a
            // label was passed.
            for (const auto& dest : GetAllDestinationsForKey(pubkey)) {
                if (!request.params[1].isNull() || pwallet->mapAddressBook.count(dest) == 0) {
                    pwallet->SetAddressBook(dest, strLabel, ""receive"");
                }
            }

            // Use timestamp of 1 to scan the whole chain
            if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
            }

            // Add the wpkh script for this key if possible
            if (pubkey.IsCompressed()) {
                pwallet->ImportScripts({GetScriptForDestination(WitnessV0KeyHash(vchAddress))}, 0 /* timestamp */);
            }
        }
    }
    if (fRescan) {
        RescanWallet(*pwallet, reserver);
    }

    return NullUniValue;
}

UniValue abortrescan(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""abortrescan"",
                ""\\nStops current wallet rescan triggered by an RPC call, e.g. by an importprivkey call.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {},
                RPCResults{},
                RPCExamples{
            ""\\nImport a private key\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nAbort the running wallet rescan\\n""
            + HelpExampleCli(""abortrescan"", """") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""abortrescan"", """")
                },
            }.Check(request);

    if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
    pwallet->AbortRescan();
    return true;
}

UniValue importaddress(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importaddress"",
                ""\\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""If you have the full public key, you should call importpubkey instead of this.\\n""
            ""Hint: use importmulti to import more than one address.\\n""
            ""\\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\\n""
            ""as change, and not show up in many RPCs.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The Wazzle address (or hex-encoded script)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                    {""p2sh"", RPCArg::Type::BOOL, /* default */ ""false"", ""Add the P2SH version of the script as well""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nImport an address with rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importaddress"", ""\\""myaddress\\"", \\""testing\\"", false"")
                },
            }.Check(request);


    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    // Whether to import a p2sh version, too
    bool fP2SH = false;
    if (!request.params[3].isNull())
        fP2SH = request.params[3].get_bool();

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        CTxDestination dest = DecodeDestination(request.params[0].get_str());
        if (IsValidDestination(dest)) {
            if (fP2SH) {
                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Cannot use the p2sh flag with an address - use a script instead"");
            }

            pwallet->MarkDirty();

            pwallet->ImportScriptPubKeys(strLabel, {GetScriptForDestination(dest)}, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else if (IsHex(request.params[0].get_str())) {
            std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
            CScript redeem_script(data.begin(), data.end());

            std::set<CScript> scripts = {redeem_script};
            pwallet->ImportScripts(scripts, 0 /* timestamp */);

            if (fP2SH) {
                scripts.insert(GetScriptForDestination(ScriptHash(CScriptID(redeem_script))));
            }

            pwallet->ImportScriptPubKeys(strLabel, scripts, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Wazzle address or script"");
        }
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions(*locked_chain);
        }
    }

    return NullUniValue;
}

UniValue importprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprunedfunds"",
                ""\\nImports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\\n"",
                {
                    {""rawtransaction"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""A raw transaction in hex funding an already-existing address in wallet""},
                    {""txoutproof"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex output from gettxoutproof that contains the transaction""},
                },
                RPCResults{},
                RPCExamples{""""},
            }.Check(request);

    CMutableTransaction tx;
    if (!DecodeHexTx(tx, request.params[0].get_str()))
        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, ""TX decode failed"");
    uint256 hashTx = tx.GetHash();
    CWalletTx wtx(pwallet, MakeTransactionRef(std::move(tx)));

    CDataStream ssMB(ParseHexV(request.params[1], ""proof""), SER_NETWORK, PROTOCOL_VERSION);
    CMerkleBlock merkleBlock;
    ssMB >> merkleBlock;

    //Search partial merkle tree in proof for our transaction and index in valid block
    std::vector<uint256> vMatch;
    std::vector<unsigned int> vIndex;
    unsigned int txnIndex = 0;
    if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) == merkleBlock.header.hashMerkleRoot) {

        auto locked_chain = pwallet->chain().lock();
        if (locked_chain->getBlockHeight(merkleBlock.header.GetHash()) == nullopt) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found in chain"");
        }

        std::vector<uint256>::const_iterator it;
        if ((it = std::find(vMatch.begin(), vMatch.end(), hashTx))==vMatch.end()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction given doesn't exist in proof"");
        }

        txnIndex = vIndex[it - vMatch.begin()];
    }
    else {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Something wrong with merkleblock"");
    }

    wtx.SetConf(CWalletTx::Status::CONFIRMED, merkleBlock.header.GetHash(), txnIndex);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    if (pwallet->IsMine(*wtx.tx)) {
        pwallet->AddToWallet(wtx, false);
        return NullUniValue;
    }

    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""No addresses in wallet correspond to included transaction"");
}

UniValue removeprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""removeprunedfunds"",
                ""\\nDeletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\\n"",
                {
                    {""txid"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex-encoded id of the transaction you are deleting""},
                },
                RPCResults{},
                RPCExamples{
                    HelpExampleCli(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    uint256 hash(ParseHashV(request.params[0], ""txid""));
    std::vector<uint256> vHash;
    vHash.push_back(hash);
    std::vector<uint256> vHashOut;

    if (pwallet->ZapSelectTx(vHash, vHashOut) != DBErrors::LOAD_OK) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Could not properly delete the transaction."");
    }

    if(vHashOut.empty()) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Transaction does not exist in wallet."");
    }

    return NullUniValue;
}

UniValue importpubkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importpubkey"",
                ""\\nAdds a public key (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one public key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported pubkey exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""pubkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The hex-encoded public key""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nImport a public key with rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importpubkey"", ""\\""mypubkey\\"", \\""testing\\"", false"")
                },
            }.Check(request);


    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    if (!IsHex(request.params[0].get_str()))
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey must be a hex string"");
    std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
    CPubKey pubKey(data.begin(), data.end());
    if (!pubKey.IsFullyValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey is not a valid public key"");

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        std::set<CScript> script_pub_keys;
        for (const auto& dest : GetAllDestinationsForKey(pubKey)) {
            script_pub_keys.insert(GetScriptForDestination(dest));
        }

        pwallet->MarkDirty();

        pwallet->ImportScriptPubKeys(strLabel, script_pub_keys, true /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);

        pwallet->ImportPubKeys({pubKey.GetID()}, {{pubKey.GetID(), pubKey}} , {} /* key_origins */, false /* add_keypool */, false /* internal */, 1 /* timestamp */);
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions(*locked_chain);
        }
    }

    return NullUniValue;
}


UniValue importwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importwallet"",
                ""\\nImports keys from a wallet dump file (see dumpwallet). Requires a new wallet backup to include imported keys.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The wallet file""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nDump the wallet\\n""
            + HelpExampleCli(""dumpwallet"", ""\\""test\\"""") +
            ""\\nImport the wallet\\n""
            + HelpExampleCli(""importwallet"", ""\\""test\\"""") +
            ""\\nImport using the json rpc call\\n""
            + HelpExampleRpc(""importwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    if (pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (!reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t nTimeBegin = 0;
    bool fGood = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        fsbridge::ifstream file;
        file.open(request.params[0].get_str(), std::ios::in | std::ios::ate);
        if (!file.is_open()) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");
        }
        Optional<int> tip_height = locked_chain->getHeight();
        nTimeBegin = tip_height ? locked_chain->getBlockTime(*tip_height) : 0;

        int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
        file.seekg(0, file.beg);

        // Use uiInterface.ShowProgress instead of pwallet.ShowProgress because pwallet.ShowProgress has a cancel button tied to AbortRescan which
        // we don't want for this progress bar showing the import progress. uiInterface.ShowProgress does not have a cancel button.
        pwallet->chain().showProgress(strprintf(""%s "" + _(""Importing..."").translated, pwallet->GetDisplayName()), 0, false); // show progress dialog in GUI
        std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
        std::vector<std::pair<CScript, int64_t>> scripts;
        while (file.good()) {
            pwallet->chain().showProgress("""", std::max(1, std::min(50, (int)(((double)file.tellg() / (double)nFilesize) * 100))), false);
            std::string line;
            std::getline(file, line);
            if (line.empty() || line[0] == '#')
                continue;

            std::vector<std::string> vstr;
            boost::split(vstr, line, boost::is_any_of("" ""));
            if (vstr.size() < 2)
                continue;
            CKey key = DecodeSecret(vstr[0]);
            if (key.IsValid()) {
                int64_t nTime = DecodeDumpTime(vstr[1]);
                std::string strLabel;
                bool fLabel = true;
                for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
                    if (vstr[nStr].front() == '#')
                        break;
                    if (vstr[nStr] == ""change=1"")
                        fLabel = false;
                    if (vstr[nStr] == ""reserve=1"")
                        fLabel = false;
                    if (vstr[nStr].substr(0,6) == ""label="") {
                        strLabel = DecodeDumpString(vstr[nStr].substr(6));
                        fLabel = true;
                    }
                }
                keys.push_back(std::make_tuple(key, nTime, fLabel, strLabel));
            } else if(IsHex(vstr[0])) {
                std::vector<unsigned char> vData(ParseHex(vstr[0]));
                CScript script = CScript(vData.begin(), vData.end());
                int64_t birth_time = DecodeDumpTime(vstr[1]);
                scripts.push_back(std::pair<CScript, int64_t>(script, birth_time));
            }
        }
        file.close();
        // We now know whether we are importing private keys, so we can error if private keys are disabled
        if (keys.size() > 0 && pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
            throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when private keys are disabled"");
        }
        double total = (double)(keys.size() + scripts.size());
        double progress = 0;
        for (const auto& key_tuple : keys) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CKey& key = std::get<0>(key_tuple);
            int64_t time = std::get<1>(key_tuple);
            bool has_label = std::get<2>(key_tuple);
            std::string label = std::get<3>(key_tuple);

            CPubKey pubkey = key.GetPubKey();
            assert(key.VerifyPubKey(pubkey));
            CKeyID keyid = pubkey.GetID();

            pwallet->WalletLogPrintf(""Importing %s...\\n"", EncodeDestination(PKHash(keyid)));

            if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
                pwallet->WalletLogPrintf(""Error importing key for %s\\n"", EncodeDestination(PKHash(keyid)));
                fGood = false;
                continue;
            }

            if (has_label)
                pwallet->SetAddressBook(PKHash(keyid), label, ""receive"");

            nTimeBegin = std::min(nTimeBegin, time);
            progress++;
        }
        for (const auto& script_pair : scripts) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CScript& script = script_pair.first;
            int64_t time = script_pair.second;

            if (!pwallet->ImportScripts({script}, time)) {
                pwallet->WalletLogPrintf(""Error importing script %s\\n"", HexStr(script));
                fGood = false;
                continue;
            }
            if (time > 0) {
                nTimeBegin = std::min(nTimeBegin, time);
            }

            progress++;
        }
        pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    }
    pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
    pwallet->MarkDirty();

    if (!fGood)
        throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding some keys/scripts to wallet"");

    return NullUniValue;
}

UniValue dumpprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpprivkey"",
                ""\\nReveals the private key corresponding to 'address'.\\n""
                ""Then the importprivkey can be used with this output\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The wazzle address for the private key""},
                },
                RPCResult{
            ""\\""key\\""                (string) The private key\\n""
                },
                RPCExamples{
                    HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""")
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""")
            + HelpExampleRpc(""dumpprivkey"", ""\\""myaddress\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    EnsureWalletIsUnlocked(pwallet);

    std::string strAddress = request.params[0].get_str();
    CTxDestination dest = DecodeDestination(strAddress);
    if (!IsValidDestination(dest)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Wazzle address"");
    }
    auto keyid = GetKeyForDestination(*pwallet, dest);
    if (keyid.IsNull()) {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Address does not refer to a key"");
    }
    CKey vchSecret;
    if (!pwallet->GetKey(keyid, vchSecret)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Private key for address "" + strAddress + "" is not known"");
    }
    return EncodeSecret(vchSecret);
}


UniValue dumpwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpwallet"",
                ""\\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\\n""
                ""Imported scripts are included in the dumpfile, but corresponding BIP173 addresses, etc. may not be added automatically by importwallet.\\n""
                ""Note that if your wallet contains keys which are not derived from your HD seed (e.g. imported keys), these are not covered by\\n""
                ""only backing up the seed itself, and must be backed up too (e.g. ensure you back up the whole dumpfile).\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The filename with path (either absolute or relative to wazzled)""},
                },
                RPCResult{
            ""{                           (json object)\\n""
            ""  \\""filename\\"" : {        (string) The filename with full absolute path\\n""
            ""}\\n""
                },
                RPCExamples{
                    HelpExampleCli(""dumpwallet"", ""\\""test\\"""")
            + HelpExampleRpc(""dumpwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    EnsureWalletIsUnlocked(pwallet);

    fs::path filepath = request.params[0].get_str();
    filepath = fs::absolute(filepath);

    /* Prevent arbitrary files from being overwritten. There have been reports
     * that users have overwritten wallet files this way:
     * https://github.com/wazzle/wazzle/issues/9934
     * It may also avoid other security issues.
     */
    if (fs::exists(filepath)) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, filepath.string() + "" already exists. If you are sure this is what you want, move it out of the way first"");
    }

    fsbridge::ofstream file;
    file.open(filepath);
    if (!file.is_open())
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");

    std::map<CKeyID, int64_t> mapKeyBirth;
    const std::map<CKeyID, int64_t>& mapKeyPool = pwallet->GetAllReserveKeys();
    pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);

    std::set<CScriptID> scripts = pwallet->GetCScripts();

    // sort time/key pairs
    std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
    for (const auto& entry : mapKeyBirth) {
        vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
    }
    mapKeyBirth.clear();
    std::sort(vKeyBirth.begin(), vKeyBirth.end());

    // produce output
    file << strprintf(""# Wallet dump created by Wazzle %s\\n"", CLIENT_BUILD);
    file << strprintf(""# * Created on %s\\n"", FormatISO8601DateTime(GetTime()));
    const Optional<int> tip_height = locked_chain->getHeight();
    file << strprintf(""# * Best block at time of backup was %i (%s),\\n"", tip_height.get_value_or(-1), tip_height ? locked_chain->getBlockHash(*tip_height).ToString() : ""(missing block hash)"");
    file << strprintf(""#   mined on %s\\n"", tip_height ? FormatISO8601DateTime(locked_chain->getBlockTime(*tip_height)) : ""(missing block time)"");
    file << ""\\n"";

    // add the base58check encoded extended master if the wallet uses HD
    CKeyID seed_id = pwallet->GetHDChain().seed_id;
    if (!seed_id.IsNull())
    {
        CKey seed;
        if (pwallet->GetKey(seed_id, seed)) {
            CExtKey masterKey;
            masterKey.SetSeed(seed.begin(), seed.size());

            file << ""# extended private masterkey: "" << EncodeExtKey(masterKey) << ""\\n\\n"";
        }
    }
    for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
        const CKeyID &keyid = it->second;
        std::string strTime = FormatISO8601DateTime(it->first);
        std::string strAddr;
        std::string strLabel;
        CKey key;
        if (pwallet->GetKey(keyid, key)) {
            file << strprintf(""%s %s "", EncodeSecret(key), strTime);
            if (GetWalletAddressesForKey(pwallet, keyid, strAddr, strLabel)) {
               file << strprintf(""label=%s"", strLabel);
            } else if (keyid == seed_id) {
                file << ""hdseed=1"";
            } else if (mapKeyPool.count(keyid)) {
                file << ""reserve=1"";
            } else if (pwallet->mapKeyMetadata[keyid].hdKeypath == ""s"") {
                file << ""inactivehdseed=1"";
            } else {
                file << ""change=1"";
            }
            file << strprintf("" # addr=%s%s\\n"", strAddr, (pwallet->mapKeyMetadata[keyid].has_key_origin ? "" hdkeypath=""+WriteHDKeypath(pwallet->mapKeyMetadata[keyid].key_origin.path) : """"));
        }
    }
    file << ""\\n"";
    for (const CScriptID &scriptid : scripts) {
        CScript script;
        std::string create_time = ""0"";
        std::string address = EncodeDestination(ScriptHash(scriptid));
        // get birth times for scripts with metadata
        auto it = pwallet->m_script_metadata.find(scriptid);
        if (it != pwallet->m_script_metadata.end()) {
            create_time = FormatISO8601DateTime(it->second.nCreateTime);
        }
        if(pwallet->GetCScript(scriptid, script)) {
            file << strprintf(""%s %s script=1"", HexStr(script.begin(), script.end()), create_time);
            file << strprintf("" # addr=%s\\n"", address);
        }
    }
    file << ""\\n"";
    file << ""# End of dump\\n"";
    file.close();

    UniValue reply(UniValue::VOBJ);
    reply.pushKV(""filename"", filepath.string());

    return reply;
}

struct ImportData
{
    // Input data
    std::unique_ptr<CScript> redeemscript; //!< Provided redeemScript; will be moved to `import_scripts` if relevant.
    std::unique_ptr<CScript> witnessscript; //!< Provided witnessScript; will be moved to `import_scripts` if relevant.

    // Output data
    std::set<CScript> import_scripts;
    std::map<CKeyID, bool> used_keys; //!< Import these private keys if available (the value indicates whether if the key is required for solvability)
    std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> key_origins;
};

enum class ScriptContext
{
    TOP, //!< Top-level scriptPubKey
    P2SH, //!< P2SH redeemScript
    WITNESS_V0, //!< P2WSH witnessScript
};

// Analyse the provided scriptPubKey, determining which keys and which redeem scripts from the ImportData struct are needed to spend it, and mark them as used.
// Returns an error string, or the empty string for success.
static std::string RecurseImportData(const CScript& script, ImportData& import_data, const ScriptContext script_ctx)
{
    // Use Solver to obtain script type and parsed pubkeys or hashes:
    std::vector<std::vector<unsigned char>> solverdata;
    txnouttype script_type = Solver(script, solverdata);

    switch (script_type) {
    case TX_PUBKEY: {
        CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
        import_data.used_keys.emplace(pubkey.GetID(), false);
        return """";
    }
    case TX_PUBKEYHASH: {
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        return """";
    }
    case TX_SCRIPTHASH: {
        if (script_ctx == ScriptContext::P2SH) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside another P2SH"");
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside a P2WSH"");
        assert(script_ctx == ScriptContext::TOP);
        CScriptID id = CScriptID(uint160(solverdata[0]));
        auto subscript = std::move(import_data.redeemscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing redeemscript"";
        if (CScriptID(*subscript) != id) return ""redeemScript does not match the scriptPubKey"";
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::P2SH);
    }
    case TX_MULTISIG: {
        for (size_t i = 1; i + 1< solverdata.size(); ++i) {
            CPubKey pubkey(solverdata[i].begin(), solverdata[i].end());
            import_data.used_keys.emplace(pubkey.GetID(), false);
        }
        return """";
    }
    case TX_WITNESS_V0_SCRIPTHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WSH inside another P2WSH"");
        uint256 fullid(solverdata[0]);
        CScriptID id;
        CRIPEMD160().Write(fullid.begin(), fullid.size()).Finalize(id.begin());
        auto subscript = std::move(import_data.witnessscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing witnessscript"";
        if (CScriptID(*subscript) != id) return ""witnessScript does not match the scriptPubKey or redeemScript"";
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WSH requires the TOP script imported (see script/ismine.cpp)
        }
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::WITNESS_V0);
    }
    case TX_WITNESS_V0_KEYHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WPKH inside P2WSH"");
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WPKH requires the TOP script imported (see script/ismine.cpp)
        }
        return """";
    }
    case TX_NULL_DATA:
        return ""unspendable script"";
    case TX_NONSTANDARD:
    case TX_WITNESS_UNKNOWN:
    default:
        return ""unrecognized script"";
    }
}

static UniValue ProcessImportLegacy(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    // First ensure scriptPubKey has either a script or JSON with ""address"" string
    const UniValue& scriptPubKey = data[""scriptPubKey""];
    bool isScript = scriptPubKey.getType() == UniValue::VSTR;
    if (!isScript && !(scriptPubKey.getType() == UniValue::VOBJ && scriptPubKey.exists(""address""))) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""scriptPubKey must be string with script or JSON with address string"");
    }
    const std::string& output = isScript ? scriptPubKey.get_str() : scriptPubKey[""address""].get_str();

    // Optional fields.
    const std::string& strRedeemScript = data.exists(""redeemscript"") ? data[""redeemscript""].get_str() : """";
    const std::string& witness_script_hex = data.exists(""witnessscript"") ? data[""witnessscript""].get_str() : """";
    const UniValue& pubKeys = data.exists(""pubkeys"") ? data[""pubkeys""].get_array() : UniValue();
    const UniValue& keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();
    const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
    const bool watchOnly = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    if (data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for a non-descriptor import"");
    }

    // Generate the script and destination for the scriptPubKey provided
    CScript script;
    if (!isScript) {
        CTxDestination dest = DecodeDestination(output);
        if (!IsValidDestination(dest)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid address \\"""" + output + ""\\"""");
        }
        script = GetScriptForDestination(dest);
    } else {
        if (!IsHex(output)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid scriptPubKey \\"""" + output + ""\\"""");
        }
        std::vector<unsigned char> vData(ParseHex(output));
        script = CScript(vData.begin(), vData.end());
        CTxDestination dest;
        if (!ExtractDestination(script, dest) && !internal) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal must be set to true for nonstandard scriptPubKey imports."");
        }
    }
    script_pub_keys.emplace(script);

    // Parse all arguments
    if (strRedeemScript.size()) {
        if (!IsHex(strRedeemScript)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid redeem script \\"""" + strRedeemScript + ""\\"": must be hex string"");
        }
        auto parsed_redeemscript = ParseHex(strRedeemScript);
        import_data.redeemscript = MakeUnique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
    }
    if (witness_script_hex.size()) {
        if (!IsHex(witness_script_hex)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid witness script \\"""" + witness_script_hex + ""\\"": must be hex string"");
        }
        auto parsed_witnessscript = ParseHex(witness_script_hex);
        import_data.witnessscript = MakeUnique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
    }
    for (size_t i = 0; i < pubKeys.size(); ++i) {
        const auto& str = pubKeys[i].get_str();
        if (!IsHex(str)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" must be a hex string"");
        }
        auto parsed_pubkey = ParseHex(str);
        CPubKey pubkey(parsed_pubkey.begin(), parsed_pubkey.end());
        if (!pubkey.IsFullyValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" is not a valid public key"");
        }
        pubkey_map.emplace(pubkey.GetID(), pubkey);
        ordered_pubkeys.push_back(pubkey.GetID());
    }
    for (size_t i = 0; i < keys.size(); ++i) {
        const auto& str = keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();
        if (pubkey_map.count(id)) {
            pubkey_map.erase(id);
        }
        privkey_map.emplace(id, key);
    }


    // Verify and process input data
    have_solving_data = import_data.redeemscript || import_data.witnessscript || pubkey_map.size() || privkey_map.size();
    if (have_solving_data) {
        // Match up data in import_data with the scriptPubKey in script.
        auto error = RecurseImportData(script, import_data, ScriptContext::TOP);

        // Verify whether the watchonly option corresponds to the availability of private keys.
        bool spendable = std::all_of(import_data.used_keys.begin(), import_data.used_keys.end(), [&](const std::pair<CKeyID, bool>& used_key){ return privkey_map.count(used_key.first) > 0; });
        if (!watchOnly && !spendable) {
            warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
        }
        if (watchOnly && spendable) {
            warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
        }

        // Check that all required keys for solvability are provided.
        if (error.empty()) {
            for (const auto& require_key : import_data.used_keys) {
                if (!require_key.second) continue; // Not a required key
                if (pubkey_map.count(require_key.first) == 0 && privkey_map.count(require_key.first) == 0) {
                    error = ""some required keys are missing"";
                }
            }
        }

        if (!error.empty()) {
            warnings.push_back(""Importing as non-solvable: "" + error + "". If this is intentional, don't provide any keys, pubkeys, witnessscript, or redeemscript."");
            import_data = ImportData();
            pubkey_map.clear();
            privkey_map.clear();
            have_solving_data = false;
        } else {
            // RecurseImportData() removes any relevant redeemscript/witnessscript from import_data, so we can use that to discover if a superfluous one was provided.
            if (import_data.redeemscript) warnings.push_back(""Ignoring redeemscript as this is not a P2SH script."");
            if (import_data.witnessscript) warnings.push_back(""Ignoring witnessscript as this is not a (P2SH-)P2WSH script."");
            for (auto it = privkey_map.begin(); it != privkey_map.end(); ) {
                auto oldit = it++;
                if (import_data.used_keys.count(oldit->first) == 0) {
                    warnings.push_back(""Ignoring irrelevant private key."");
                    privkey_map.erase(oldit);
                }
            }
            for (auto it = pubkey_map.begin(); it != pubkey_map.end(); ) {
                auto oldit = it++;
                auto key_data_it = import_data.used_keys.find(oldit->first);
                if (key_data_it == import_data.used_keys.end() || !key_data_it->second) {
                    warnings.push_back(""Ignoring public key \\"""" + HexStr(oldit->first) + ""\\"" as it doesn't appear inside P2PKH or P2WPKH."");
                    pubkey_map.erase(oldit);
                }
            }
        }
    }

    return warnings;
}

static UniValue ProcessImportDescriptor(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    const std::string& descriptor = data[""desc""].get_str();
    FlatSigningProvider keys;
    std::string error;
    auto parsed_desc = Parse(descriptor, keys, error, /* require_checksum = */ true);
    if (!parsed_desc) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
    }

    have_solving_data = parsed_desc->IsSolvable();
    const bool watch_only = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    int64_t range_start = 0, range_end = 0;
    if (!parsed_desc->IsRange() && data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for an un-ranged descriptor"");
    } else if (parsed_desc->IsRange()) {
        if (!data.exists(""range"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Descriptor is ranged, please specify the range"");
        }
        std::tie(range_start, range_end) = ParseDescriptorRange(data[""range""]);
    }

    const UniValue& priv_keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();

    // Expand all descriptors to get public keys and scripts, and private keys if available.
    for (int i = range_start; i <= range_end; ++i) {
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        parsed_desc->Expand(i, keys, scripts_temp, out_keys);
        std::copy(scripts_temp.begin(), scripts_temp.end(), std::inserter(script_pub_keys, script_pub_keys.end()));
        for (const auto& key_pair : out_keys.pubkeys) {
            ordered_pubkeys.push_back(key_pair.first);
        }

        for (const auto& x : out_keys.scripts) {
            import_data.import_scripts.emplace(x.second);
        }

        parsed_desc->ExpandPrivate(i, keys, out_keys);

        std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(), std::inserter(pubkey_map, pubkey_map.end()));
        std::copy(out_keys.keys.begin(), out_keys.keys.end(), std::inserter(privkey_map, privkey_map.end()));
        import_data.key_origins.insert(out_keys.origins.begin(), out_keys.origins.end());
    }

    for (size_t i = 0; i < priv_keys.size(); ++i) {
        const auto& str = priv_keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();

        // Check if this private key corresponds to a public key from the descriptor
        if (!pubkey_map.count(id)) {
            warnings.push_back(""Ignoring irrelevant private key."");
        } else {
            privkey_map.emplace(id, key);
        }
    }

    // Check if all the public keys have corresponding private keys in the import for spendability.
    // This does not take into account threshold multisigs which could be spendable without all keys.
    // Thus, threshold multisigs without all keys will be considered not spendable here, even if they are,
    // perhaps triggering a false warning message. This is consistent with the current wallet IsMine check.
    bool spendable = std::all_of(pubkey_map.begin(), pubkey_map.end(),
        [&](const std::pair<CKeyID, CPubKey>& used_key) {
            return privkey_map.count(used_key.first) > 0;
        }) && std::all_of(import_data.key_origins.begin(), import_data.key_origins.end(),
        [&](const std::pair<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& entry) {
            return privkey_map.count(entry.first) > 0;
        });
    if (!watch_only && !spendable) {
        warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
    }
    if (watch_only && spendable) {
        warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
    }

    return warnings;
}

static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    UniValue warnings(UniValue::VARR);
    UniValue result(UniValue::VOBJ);

    try {
        const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
        // Internal addresses should not have a label
        if (internal && data.exists(""label"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal addresses should not have a label"");
        }
        const std::string& label = data.exists(""label"") ? data[""label""].get_str() : """";
        const bool add_keypool = data.exists(""keypool"") ? data[""keypool""].get_bool() : false;

        // Add to keypool only works with privkeys disabled
        if (add_keypool && !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Keys can only be imported to the keypool when private keys are disabled"");
        }

        ImportData import_data;
        std::map<CKeyID, CPubKey> pubkey_map;
        std::map<CKeyID, CKey> privkey_map;
        std::set<CScript> script_pub_keys;
        std::vector<CKeyID> ordered_pubkeys;
        bool have_solving_data;

        if (data.exists(""scriptPubKey"") && data.exists(""desc"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Both a descriptor and a scriptPubKey should not be provided."");
        } else if (data.exists(""scriptPubKey"")) {
            warnings = ProcessImportLegacy(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else if (data.exists(""desc"")) {
            warnings = ProcessImportDescriptor(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Either a descriptor or scriptPubKey must be provided."");
        }

        // If private keys are disabled, abort if private keys are being imported
        if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !privkey_map.empty()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
        }

        // Check whether we have any work to do
        for (const CScript& script : script_pub_keys) {
            if (::IsMine(*pwallet, script) & ISMINE_SPENDABLE) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""The wallet already contains the private key for this address or script (\\"""" + HexStr(script.begin(), script.end()) + ""\\"")"");
            }
        }

        // All good, time to import
        pwallet->MarkDirty();
        if (!pwallet->ImportScripts(import_data.import_scripts, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding script to wallet"");
        }
        if (!pwallet->ImportPrivKeys(privkey_map, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
        }
        if (!pwallet->ImportPubKeys(ordered_pubkeys, pubkey_map, import_data.key_origins, add_keypool, internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }
        if (!pwallet->ImportScriptPubKeys(label, script_pub_keys, have_solving_data, !internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }

        result.pushKV(""success"", UniValue(true));
    } catch (const UniValue& e) {
        result.pushKV(""success"", UniValue(false));
        result.pushKV(""error"", e);
    } catch (...) {
        result.pushKV(""success"", UniValue(false));

        result.pushKV(""error"", JSONRPCError(RPC_MISC_ERROR, ""Missing required fields""));
    }
    if (warnings.size()) result.pushKV(""warnings"", warnings);
    return result;
}

static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
{
    if (data.exists(""timestamp"")) {
        const UniValue& timestamp = data[""timestamp""];
        if (timestamp.isNum()) {
            return timestamp.get_int64();
        } else if (timestamp.isStr() && timestamp.get_str() == ""now"") {
            return now;
        }
        throw JSONRPCError(RPC_TYPE_ERROR, strprintf(""Expected number or \\""now\\"" timestamp value for key. got type %s"", uvTypeName(timestamp.type())));
    }
    throw JSONRPCError(RPC_TYPE_ERROR, ""Missing required timestamp field for key"");
}

UniValue importmulti(const JSONRPCRequest& mainRequest)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importmulti"",
                ""\\nImport addresses/scripts (with private or public keys, redeem script (P2SH)), optionally rescanning the blockchain from the earliest creation time of the imported scripts. Requires a new wallet backup.\\n""
                ""If an address/script is imported without all of the private keys required to spend from that address, it will be watchonly. The 'watchonly' option must be set to true in this case or a warning will be returned.\\n""
                ""Conversely, if all the private keys are provided and the address/script is spendable, the watchonly option must be set to false, or a warning will be returned.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported keys, addresses or scripts exist but related transactions are still missing.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""requests"", RPCArg::Type::ARR, RPCArg::Optional::NO, ""Data to be imported"",
                        {
                            {"""", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, """",
                                {
                                    {""desc"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Descriptor to import. If using descriptor, do not also provide address/scriptPubKey, scripts, or pubkeys""},
                                    {""scriptPubKey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""Type of scriptPubKey (string for script, json for address). Should not be provided if using a descriptor"",
                                        /* oneline_description */ """", {""\\""<script>\\"" | { \\""address\\"":\\""<address>\\"" }"", ""string / json""}
                                    },
                                    {""timestamp"", RPCArg::Type::NUM, RPCArg::Optional::NO, ""Creation time of the key in seconds since epoch (Jan 1 1970 GMT),\\n""
        ""                                                              or the string \\""now\\"" to substitute the current synced blockchain time. The timestamp of the oldest\\n""
        ""                                                              key will determine how far back blockchain rescans need to begin for missing wallet transactions.\\n""
        ""                                                              \\""now\\"" can be specified to bypass scanning, for keys which are known to never have been used, and\\n""
        ""                                                              0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest key\\n""
        ""                                                              creation time of all keys being imported by the importmulti call will be scanned."",
                                        /* oneline_description */ """", {""timestamp | \\""now\\"""", ""integer / string""}
                                    },
                                    {""redeemscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH or P2SH-P2WSH address/scriptPubKey""},
                                    {""witnessscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH-P2WSH or P2WSH address/scriptPubKey""},
                                    {""pubkeys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving pubkeys to import. They must occur in P2PKH or P2WPKH scripts. They are not required when the private key is also provided (see the \\""keys\\"" argument)."",
                                        {
                                            {""pubKey"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""keys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving private keys to import. The corresponding public keys must occur in the output or redeemscript."",
                                        {
                                            {""key"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""range"", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, ""If a ranged descriptor is used, this specifies the end or the range (in the form [begin,end]) to import""},
                                    {""internal"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be treated as not incoming payments (also known as change)""},
                                    {""watchonly"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be considered watchonly.""},
                                    {""label"", RPCArg::Type::STR, /* default */ ""''"", ""Label to assign to the address, only allowed with internal=false""},
                                    {""keypool"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether imported public keys should be added to the keypool for when users request new addresses. Only allowed when wallet private keys are disabled""},
                                },
                            },
                        },
                        ""\\""requests\\""""},
                    {""options"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, """",
                        {
                            {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Stating if should rescan the blockchain after all imports""},
                        },
                        ""\\""options\\""""},
                },
                RPCResult{
            ""\\nResponse is an array with the same size as the input that has the execution result :\\n""
            ""  [{\\""success\\"": true}, {\\""success\\"": true, \\""warnings\\"": [\\""Ignoring irrelevant private key\\""]}, {\\""success\\"": false, \\""error\\"": {\\""code\\"": -1, \\""message\\"": \\""Internal Server Error\\""}}, ...]\\n""
                },
                RPCExamples{
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }, ""
                                          ""{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my 2nd address>\\"" }, \\""label\\"": \\""example 2\\"", \\""timestamp\\"": 1455191480 }]'"") +
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }]' '{ \\""rescan\\"": false}'"")
                },
            }.Check(mainRequest);


    RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});

    const UniValue& requests = mainRequest.params[0];

    //Default options
    bool fRescan = true;

    if (!mainRequest.params[1].isNull()) {
        const UniValue& options = mainRequest.params[1];

        if (options.exists(""rescan"")) {
            fRescan = options[""rescan""].get_bool();
        }
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t now = 0;
    bool fRunScan = false;
    int64_t nLowestTimestamp = 0;
    UniValue response(UniValue::VARR);
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);
        EnsureWalletIsUnlocked(pwallet);

        // Verify all timestamps are present before importing any keys.
        const Optional<int> tip_height = locked_chain->getHeight();
        now = tip_height ? locked_chain->getBlockMedianTimePast(*tip_height) : 0;
        for (const UniValue& data : requests.getValues()) {
            GetImportTimestamp(data, now);
        }

        const int64_t minimumTimestamp = 1;

        if (fRescan && tip_height) {
            nLowestTimestamp = locked_chain->getBlockTime(*tip_height);
        } else {
            fRescan = false;
        }

        for (const UniValue& data : requests.getValues()) {
            const int64_t timestamp = std::max(GetImportTimestamp(data, now), minimumTimestamp);
            const UniValue result = ProcessImport(pwallet, data, timestamp);
            response.push_back(result);

            if (!fRescan) {
                continue;
            }

            // If at least one request was successful then allow rescan.
            if (result[""success""].get_bool()) {
                fRunScan = true;
            }

            // Get the lowest timestamp.
            if (timestamp < nLowestTimestamp) {
                nLowestTimestamp = timestamp;
            }
        }
    }
    if (fRescan && fRunScan && requests.size()) {
        int64_t scannedTime = pwallet->RescanFromTime(nLowestTimestamp, reserver, true /* update */);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions(*locked_chain);
        }

        if (pwallet->IsAbortingRescan()) {
            throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
        }
        if (scannedTime > nLowestTimestamp) {
            std::vector<UniValue> results = response.getValues();
            response.clear();
            response.setArray();
            size_t i = 0;
            for (const UniValue& request : requests.getValues()) {
                // If key creation date is within the successfully scanned
                // range, or if the import result already has an error set, let
                // the result stand unmodified. Otherwise replace the result
                // with an error message.
                if (scannedTime <= GetImportTimestamp(request, now) || results.at(i).exists(""error"")) {
                    response.push_back(results.at(i));
                } else {
                    UniValue result = UniValue(UniValue::VOBJ);
                    result.pushKV(""success"", UniValue(false));
                    result.pushKV(
                        ""error"",
                        JSONRPCError(
                            RPC_MISC_ERROR,
                            strprintf(""Rescan failed for key with creation timestamp %d. There was an error reading a ""
                                      ""block from time %d, which is after or within %d seconds of key creation, and ""
                                      ""could contain transactions pertaining to the key. As a result, transactions ""
                                      ""and coins using this key may not appear in the wallet. This error could be ""
                                      ""caused by pruning or data corruption (see wazzled log for details) and could ""
                                      ""be dealt with by downloading and rescanning the relevant blocks (see -reindex ""
                                      ""and -rescan options)."",
                                GetImportTimestamp(request, now), scannedTime - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)));
                    response.push_back(std::move(result));
                }
                ++i;
            }
        }
    }

    return response;
}
",16159,True,3120.3407553893826,median
"CLASS zcl_abapgit_popups DEFINITION
  PUBLIC
  FINAL
  CREATE PRIVATE
  GLOBAL FRIENDS zcl_abapgit_ui_factory.

  PUBLIC SECTION.

    INTERFACES: zif_abapgit_popups.
    ALIASES:
      popup_package_export          FOR zif_abapgit_popups~popup_package_export,
      popup_folder_logic            FOR zif_abapgit_popups~popup_folder_logic,
      popup_object                  FOR zif_abapgit_popups~popup_object,
      create_branch_popup           FOR zif_abapgit_popups~create_branch_popup,
      run_page_class_popup          FOR zif_abapgit_popups~run_page_class_popup,
      repo_new_offline              FOR zif_abapgit_popups~repo_new_offline,
      branch_list_popup             FOR zif_abapgit_popups~branch_list_popup,
      repo_popup                    FOR zif_abapgit_popups~repo_popup,
      popup_to_confirm              FOR zif_abapgit_popups~popup_to_confirm,
      popup_to_inform               FOR zif_abapgit_popups~popup_to_inform,
      popup_to_create_package       FOR zif_abapgit_popups~popup_to_create_package,
      popup_to_create_transp_branch FOR zif_abapgit_popups~popup_to_create_transp_branch,
      popup_to_select_transports    FOR zif_abapgit_popups~popup_to_select_transports,
      popup_to_select_from_list     FOR zif_abapgit_popups~popup_to_select_from_list,
      branch_popup_callback         FOR zif_abapgit_popups~branch_popup_callback,
      package_popup_callback        FOR zif_abapgit_popups~package_popup_callback,
      popup_transport_request       FOR zif_abapgit_popups~popup_transport_request.

  PROTECTED SECTION.
  PRIVATE SECTION.

    TYPES:
      ty_sval_tt TYPE STANDARD TABLE OF sval WITH DEFAULT KEY.

    CONSTANTS c_fieldname_selected TYPE lvc_fname VALUE `SELECTED` ##NO_TEXT.
    CONSTANTS c_answer_cancel      TYPE char1 VALUE 'A' ##NO_TEXT.

    DATA mo_select_list_popup TYPE REF TO cl_salv_table .
    DATA mr_table TYPE REF TO data .
    DATA mv_cancel TYPE abap_bool .
    DATA mo_table_descr TYPE REF TO cl_abap_tabledescr .

    METHODS add_field
      IMPORTING
        !iv_tabname    TYPE sval-tabname
        !iv_fieldname  TYPE sval-fieldname
        !iv_fieldtext  TYPE sval-fieldtext
        !iv_value      TYPE clike DEFAULT ''
        !iv_field_attr TYPE sval-field_attr DEFAULT ''
        !iv_obligatory TYPE spo_obl OPTIONAL
      CHANGING
        !ct_fields     TYPE ty_sval_tt .
    METHODS create_new_table
      IMPORTING
        !it_list TYPE STANDARD TABLE .
    METHODS get_selected_rows
      EXPORTING
        !et_list TYPE INDEX TABLE .
    METHODS on_select_list_link_click
          FOR EVENT link_click OF cl_salv_events_table
      IMPORTING
          !row
          !column .
    METHODS on_select_list_function_click
          FOR EVENT added_function OF cl_salv_events_table
      IMPORTING
          !e_salv_function .
    METHODS extract_field_values
      IMPORTING
        it_fields       TYPE ty_sval_tt
      EXPORTING
        ev_url          TYPE abaptxt255-line
        ev_package      TYPE tdevc-devclass
        ev_branch       TYPE textl-line
        ev_display_name TYPE trm255-text
        ev_folder_logic TYPE string
        ev_ign_subpkg   TYPE abap_bool.
    TYPES:
      ty_lt_fields TYPE STANDARD TABLE OF sval WITH DEFAULT KEY.
    METHODS _popup_2_get_values
      IMPORTING iv_popup_title    TYPE string
                iv_no_value_check TYPE abap_bool DEFAULT abap_false
      EXPORTING ev_value_1        TYPE spo_value
                ev_value_2        TYPE spo_value
      CHANGING  ct_fields         TYPE ty_lt_fields
      RAISING   zcx_abapgit_exception.
    METHODS validate_folder_logic
      IMPORTING
        iv_folder_logic TYPE string
      RAISING
        zcx_abapgit_exception.
ENDCLASS.



CLASS zcl_abapgit_popups IMPLEMENTATION.


  METHOD add_field.

    FIELD-SYMBOLS: <ls_field> LIKE LINE OF ct_fields.

    APPEND INITIAL LINE TO ct_fields ASSIGNING <ls_field>.
    <ls_field>-tabname    = iv_tabname.
    <ls_field>-fieldname  = iv_fieldname.
    <ls_field>-fieldtext  = iv_fieldtext.
    <ls_field>-value      = iv_value.
    <ls_field>-field_attr = iv_field_attr.
    <ls_field>-field_obl  = iv_obligatory.

  ENDMETHOD.


  METHOD create_new_table.

    "" create and populate a table on the fly derived from
    "" it_data with a select column

    DATA: lr_struct        TYPE REF TO data,
          lt_components    TYPE cl_abap_structdescr=>component_table,
          lo_struct_descr  TYPE REF TO cl_abap_structdescr,
          lo_struct_descr2 TYPE REF TO cl_abap_structdescr.

    FIELD-SYMBOLS: <lt_table>     TYPE STANDARD TABLE,
                   <ls_component> TYPE abap_componentdescr,
                   <lg_line>      TYPE data,
                   <lg_data>      TYPE any.

    mo_table_descr ?= cl_abap_tabledescr=>describe_by_data( it_list ).
    lo_struct_descr ?= mo_table_descr->get_table_line_type( ).
    lt_components = lo_struct_descr->get_components( ).

    INSERT INITIAL LINE INTO lt_components ASSIGNING <ls_component> INDEX 1.
    ASSERT sy-subrc = 0.

    <ls_component>-name = c_fieldname_selected.
    <ls_component>-type ?= cl_abap_datadescr=>describe_by_name( 'FLAG' ).

    lo_struct_descr2 = cl_abap_structdescr=>create( lt_components ).
    mo_table_descr = cl_abap_tabledescr=>create( lo_struct_descr2 ).

    CREATE DATA mr_table TYPE HANDLE mo_table_descr.
    ASSIGN mr_table->* TO <lt_table>.
    ASSERT sy-subrc = 0.

    CREATE DATA lr_struct TYPE HANDLE lo_struct_descr2.
    ASSIGN lr_struct->* TO <lg_line>.
    ASSERT sy-subrc = 0.

    LOOP AT it_list ASSIGNING <lg_data>.
      CLEAR <lg_line>.
      MOVE-CORRESPONDING <lg_data> TO <lg_line>.
      INSERT <lg_line> INTO TABLE <lt_table>.
    ENDLOOP.

  ENDMETHOD.


  METHOD extract_field_values.

    FIELD-SYMBOLS: <ls_field> LIKE LINE OF it_fields.

    CLEAR: ev_url,
           ev_package,
           ev_branch,
           ev_display_name,
           ev_folder_logic,
           ev_ign_subpkg.

    READ TABLE it_fields INDEX 1 ASSIGNING <ls_field>.
    ASSERT sy-subrc = 0.
    ev_url = <ls_field>-value.

    READ TABLE it_fields INDEX 2 ASSIGNING <ls_field>.
    ASSERT sy-subrc = 0.
    ev_package = <ls_field>-value.
    TRANSLATE ev_package TO UPPER CASE.

    READ TABLE it_fields INDEX 3 ASSIGNING <ls_field>.
    ASSERT sy-subrc = 0.
    ev_branch = <ls_field>-value.

    READ TABLE it_fields INDEX 4 ASSIGNING <ls_field>.
    ASSERT sy-subrc = 0.
    ev_display_name = <ls_field>-value.

    READ TABLE it_fields INDEX 5 ASSIGNING <ls_field>.
    ASSERT sy-subrc = 0.
    ev_folder_logic = <ls_field>-value.
    TRANSLATE ev_folder_logic TO UPPER CASE.

    READ TABLE it_fields INDEX 6 ASSIGNING <ls_field>.
    ASSERT sy-subrc = 0.
    ev_ign_subpkg = <ls_field>-value.
    TRANSLATE ev_ign_subpkg TO UPPER CASE.

  ENDMETHOD.


  METHOD get_selected_rows.

    DATA: lv_condition TYPE string,
          lr_exporting TYPE REF TO data.

    FIELD-SYMBOLS: <lg_exporting> TYPE any,
                   <lt_table>     TYPE STANDARD TABLE,
                   <lg_line>      TYPE any.

    lv_condition = |{ c_fieldname_selected } = ABAP_TRUE|.

    ASSIGN mr_table->* TO <lt_table>.
    ASSERT sy-subrc = 0.

    CREATE DATA lr_exporting LIKE LINE OF et_list.
    ASSIGN lr_exporting->* TO <lg_exporting>.

    LOOP AT <lt_table> ASSIGNING <lg_line> WHERE (lv_condition).
      CLEAR <lg_exporting>.
      MOVE-CORRESPONDING <lg_line> TO <lg_exporting>.
      APPEND <lg_exporting> TO et_list.
    ENDLOOP.

  ENDMETHOD.


  METHOD on_select_list_function_click.

    FIELD-SYMBOLS: <lt_table>    TYPE STANDARD TABLE,
                   <lg_line>     TYPE any,
                   <lv_selected> TYPE abap_bool.

    ASSIGN mr_table->* TO <lt_table>.
    ASSERT sy-subrc = 0.

    CASE e_salv_function.
      WHEN 'O.K.'.
        mv_cancel = abap_false.
        mo_select_list_popup->close_screen( ).

      WHEN 'ABR'.
        ""Canceled: clear list to overwrite nothing
        CLEAR <lt_table>.
        mv_cancel = abap_true.
        mo_select_list_popup->close_screen( ).

      WHEN 'SALL'.

        LOOP AT <lt_table> ASSIGNING <lg_line>.

          ASSIGN COMPONENT c_fieldname_selected
                 OF STRUCTURE <lg_line>
                 TO <lv_selected>.
          ASSERT sy-subrc = 0.

          <lv_selected> = abap_true.

        ENDLOOP.

        mo_select_list_popup->refresh( ).

      WHEN 'DSEL'.

        LOOP AT <lt_table> ASSIGNING <lg_line>.

          ASSIGN COMPONENT c_fieldname_selected
                 OF STRUCTURE <lg_line>
                 TO <lv_selected>.
          ASSERT sy-subrc = 0.

          <lv_selected> = abap_false.

        ENDLOOP.

        mo_select_list_popup->refresh( ).

      WHEN OTHERS.
        CLEAR <lt_table>.
        mo_select_list_popup->close_screen( ).
    ENDCASE.

  ENDMETHOD.


  METHOD on_select_list_link_click.

    DATA: lv_line TYPE sy-tabix.

    FIELD-SYMBOLS: <lt_table>    TYPE STANDARD TABLE,
                   <lg_line>     TYPE any,
                   <lv_selected> TYPE abap_bool.

    ASSIGN mr_table->* TO <lt_table>.
    ASSERT sy-subrc = 0.

    lv_line = row.

    READ TABLE <lt_table> ASSIGNING <lg_line> INDEX lv_line.
    IF sy-subrc = 0.

      ASSIGN COMPONENT c_fieldname_selected
             OF STRUCTURE <lg_line>
             TO <lv_selected>.
      ASSERT sy-subrc = 0.

      IF <lv_selected> = abap_true.
        <lv_selected> = abap_false.
      ELSE.
        <lv_selected> = abap_true.
      ENDIF.

    ENDIF.

    mo_select_list_popup->refresh( ).
  ENDMETHOD.


  METHOD validate_folder_logic.

    IF iv_folder_logic <> zif_abapgit_dot_abapgit=>c_folder_logic-prefix
        AND iv_folder_logic <> zif_abapgit_dot_abapgit=>c_folder_logic-full.

      zcx_abapgit_exception=>raise( |Invalid folder logic { iv_folder_logic }. |
                                 && |Choose either { zif_abapgit_dot_abapgit=>c_folder_logic-prefix } |
                                 && |or { zif_abapgit_dot_abapgit=>c_folder_logic-full } | ).

    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~branch_list_popup.

    DATA: lo_branches    TYPE REF TO zcl_abapgit_git_branch_list,
          lt_branches    TYPE zif_abapgit_definitions=>ty_git_branch_list_tt,
          lv_answer      TYPE c LENGTH 1,
          lv_default     TYPE i,
          lv_head_suffix TYPE string,
          lv_head_symref TYPE string,
          lt_selection   TYPE TABLE OF spopli.

    FIELD-SYMBOLS: <ls_sel>    LIKE LINE OF lt_selection,
                   <ls_branch> LIKE LINE OF lt_branches.


    lo_branches    = zcl_abapgit_git_transport=>branches( iv_url ).
    lt_branches    = lo_branches->get_branches_only( ).
    lv_head_suffix = | ({ zif_abapgit_definitions=>c_head_name })|.
    lv_head_symref = lo_branches->get_head_symref( ).

    IF iv_hide_branch IS NOT INITIAL.
      DELETE lt_branches WHERE name = iv_hide_branch.
    ENDIF.

    IF iv_hide_head IS NOT INITIAL.
      DELETE lt_branches WHERE name    = zif_abapgit_definitions=>c_head_name
                            OR is_head = abap_true.
    ENDIF.

    IF lt_branches IS INITIAL.
      zcx_abapgit_exception=>raise( 'No branch to select' ).
    ENDIF.

    LOOP AT lt_branches ASSIGNING <ls_branch>.

      CHECK <ls_branch>-name IS NOT INITIAL. "" To ensure some below ifs

      IF <ls_branch>-is_head = abap_true.

        IF <ls_branch>-name = zif_abapgit_definitions=>c_head_name. "" HEAD
          IF <ls_branch>-name <> lv_head_symref AND lv_head_symref IS NOT INITIAL.
            "" HEAD but other HEAD symref exists - ignore
            CONTINUE.
          ELSE.
            INSERT INITIAL LINE INTO lt_selection INDEX 1 ASSIGNING <ls_sel>.
            <ls_sel>-varoption = <ls_branch>-name.
          ENDIF.
        ELSE.
          INSERT INITIAL LINE INTO lt_selection INDEX 1 ASSIGNING <ls_sel>.
          <ls_sel>-varoption = <ls_branch>-display_name && lv_head_suffix.
        ENDIF.

        IF lv_default > 0. "" Shift down default if set
          lv_default = lv_default + 1.
        ENDIF.
      ELSE.
        APPEND INITIAL LINE TO lt_selection ASSIGNING <ls_sel>.
        <ls_sel>-varoption = <ls_branch>-display_name.
      ENDIF.

      IF <ls_branch>-name = iv_default_branch.
        IF <ls_branch>-is_head = abap_true.
          lv_default = 1.
        ELSE.
          lv_default = sy-tabix.
        ENDIF.
      ENDIF.

    ENDLOOP.

    IF iv_show_new_option = abap_true.
      APPEND INITIAL LINE TO lt_selection ASSIGNING <ls_sel>.
      <ls_sel>-varoption = zif_abapgit_popups=>c_new_branch_label.
    ENDIF.

    CALL FUNCTION 'POPUP_TO_DECIDE_LIST'
      EXPORTING
        textline1  = 'Select branch'
        titel      = 'Select branch'
        start_col  = 30
        start_row  = 5
        cursorline = lv_default
      IMPORTING
        answer     = lv_answer
      TABLES
        t_spopli   = lt_selection
      EXCEPTIONS
        OTHERS     = 1.                             ""#EC NOTEXT
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'Error from POPUP_TO_DECIDE_LIST' ).
    ENDIF.

    IF lv_answer = c_answer_cancel.
      RETURN.
    ENDIF.

    READ TABLE lt_selection ASSIGNING <ls_sel> WITH KEY selflag = abap_true.
    ASSERT sy-subrc = 0.

    IF iv_show_new_option = abap_true AND <ls_sel>-varoption = zif_abapgit_popups=>c_new_branch_label.
      rs_branch-name = zif_abapgit_popups=>c_new_branch_label.
    ELSE.
      REPLACE FIRST OCCURRENCE OF lv_head_suffix IN <ls_sel>-varoption WITH ''.
      READ TABLE lt_branches WITH KEY display_name = <ls_sel>-varoption ASSIGNING <ls_branch>.
      IF sy-subrc <> 0.
* branch name longer than 65 characters
        LOOP AT lt_branches ASSIGNING <ls_branch> WHERE display_name CS <ls_sel>-varoption.
          EXIT. "" current loop
        ENDLOOP.
      ENDIF.
      ASSERT <ls_branch> IS ASSIGNED.
      rs_branch = lo_branches->find_by_name( <ls_branch>-name ).
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~branch_popup_callback.

    DATA: lv_url          TYPE string,
          ls_package_data TYPE scompkdtln,
          ls_branch       TYPE zif_abapgit_definitions=>ty_git_branch,
          lv_create       TYPE abap_bool,
          lv_text         TYPE string.

    FIELD-SYMBOLS: <ls_furl>     LIKE LINE OF ct_fields,
                   <ls_fbranch>  LIKE LINE OF ct_fields,
                   <ls_fpackage> LIKE LINE OF ct_fields.

    CLEAR cs_error.

    IF iv_code = 'COD1'.
      cv_show_popup = abap_true.

      READ TABLE ct_fields ASSIGNING <ls_furl> WITH KEY tabname = 'ABAPTXT255'.
      IF sy-subrc <> 0 OR <ls_furl>-value IS INITIAL.
        MESSAGE 'Fill URL' TYPE 'S' DISPLAY LIKE 'E'.       ""#EC NOTEXT
        RETURN.
      ENDIF.
      lv_url = <ls_furl>-value.

      ls_branch = branch_list_popup( lv_url ).
      IF ls_branch IS INITIAL.
        RETURN.
      ENDIF.

      READ TABLE ct_fields ASSIGNING <ls_fbranch> WITH KEY tabname = 'TEXTL'.
      ASSERT sy-subrc = 0.
      <ls_fbranch>-value = ls_branch-name.

    ELSEIF iv_code = 'COD2'.
      cv_show_popup = abap_true.

      READ TABLE ct_fields ASSIGNING <ls_fpackage> WITH KEY fieldname = 'DEVCLASS'.
      ASSERT sy-subrc = 0.
      ls_package_data-devclass = <ls_fpackage>-value.

      IF zcl_abapgit_factory=>get_sap_package( ls_package_data-devclass )->exists( ) = abap_true.
        lv_text = |Package { ls_package_data-devclass } already exists|.
        MESSAGE lv_text TYPE 'I' DISPLAY LIKE 'E'.
        RETURN.
      ENDIF.

      popup_to_create_package(
        IMPORTING
          es_package_data = ls_package_data
          ev_create       = lv_create ).
      IF lv_create = abap_false.
        RETURN.
      ENDIF.

      zcl_abapgit_factory=>get_sap_package( ls_package_data-devclass )->create( ls_package_data ).
      COMMIT WORK.

      <ls_fpackage>-value = ls_package_data-devclass.
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~create_branch_popup.

    DATA: lt_fields TYPE TABLE OF sval.
    DATA: lv_name   TYPE spo_value.

    CLEAR: ev_name, ev_cancel.

    add_field( EXPORTING iv_tabname   = 'TEXTL'
                         iv_fieldname = 'LINE'
                         iv_fieldtext = 'Name'
                         iv_value     = 'new-branch-name'
               CHANGING  ct_fields    = lt_fields ).

    TRY.

        _popup_2_get_values( EXPORTING iv_popup_title = 'Create branch' ""#EC NOTEXT
                             IMPORTING ev_value_1     = lv_name
                             CHANGING  ct_fields      = lt_fields ).

        ev_name = zcl_abapgit_git_branch_list=>complete_heads_branch_name(
              zcl_abapgit_git_branch_list=>normalize_branch_name( lv_name ) ).

      CATCH zcx_abapgit_cancel.
        ev_cancel = abap_true.
    ENDTRY.

  ENDMETHOD.


  METHOD zif_abapgit_popups~package_popup_callback.

    DATA: ls_package_data TYPE scompkdtln,
          lv_create       TYPE abap_bool.

    FIELD-SYMBOLS: <ls_fpackage> LIKE LINE OF ct_fields.

    CLEAR cs_error.

    IF iv_code = 'COD1'.
      cv_show_popup = abap_true.

      READ TABLE ct_fields ASSIGNING <ls_fpackage> WITH KEY fieldname = 'DEVCLASS'.
      ASSERT sy-subrc = 0.
      ls_package_data-devclass = <ls_fpackage>-value.

      popup_to_create_package( IMPORTING es_package_data = ls_package_data
                                         ev_create       = lv_create ).
      IF lv_create = abap_false.
        RETURN.
      ENDIF.

      zcl_abapgit_factory=>get_sap_package( ls_package_data-devclass )->create( ls_package_data ).
      COMMIT WORK.

      <ls_fpackage>-value = ls_package_data-devclass.
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_folder_logic.

    DATA: lt_fields       TYPE TABLE OF sval.
    DATA: lv_folder_logic TYPE spo_value.

    CLEAR: rv_folder_logic.

    add_field( EXPORTING iv_tabname   = 'TDEVC'
                         iv_fieldname = 'INTSYS'
                         iv_fieldtext = 'Folder logic'
                         iv_value     = 'PREFIX'
               CHANGING  ct_fields    = lt_fields ).

    TRY.

        _popup_2_get_values( EXPORTING iv_popup_title    = 'Export package' ""#EC NOTEXT
                                       iv_no_value_check = abap_true
                             IMPORTING ev_value_1        = lv_folder_logic
                             CHANGING  ct_fields         = lt_fields ).

        rv_folder_logic = to_upper( lv_folder_logic ).

      CATCH zcx_abapgit_cancel.
    ENDTRY.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_object.

    DATA: lt_fields      TYPE TABLE OF sval.
    DATA: lv_object_type TYPE spo_value.
    DATA: lv_object_name TYPE spo_value.

    CLEAR: rs_tadir-object, rs_tadir-obj_name.

    add_field( EXPORTING iv_tabname   = 'TADIR'
                         iv_fieldname = 'OBJECT'
                         iv_fieldtext = 'Type'
               CHANGING ct_fields     = lt_fields ).

    add_field( EXPORTING iv_tabname   = 'TADIR'
                         iv_fieldname = 'OBJ_NAME'
                         iv_fieldtext = 'Name'
               CHANGING ct_fields     = lt_fields ).

    _popup_2_get_values( EXPORTING iv_popup_title    = 'Object' ""#EC NOTEXT
                                   iv_no_value_check = abap_true
                         IMPORTING ev_value_1        = lv_object_type
                                   ev_value_2        = lv_object_name
                         CHANGING  ct_fields         = lt_fields ).

    rs_tadir = zcl_abapgit_factory=>get_tadir( )->read_single(
      iv_object   = to_upper( lv_object_type )
      iv_obj_name = to_upper( lv_object_name ) ).

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_package_export.

    DATA: lt_fields       TYPE TABLE OF sval.
    DATA: lv_package      TYPE spo_value.
    DATA: lv_folder_logic TYPE spo_value.

    add_field( EXPORTING iv_tabname   = 'TDEVC'
                         iv_fieldname = 'DEVCLASS'
                         iv_fieldtext = 'Package'
               CHANGING  ct_fields    = lt_fields ).

    add_field( EXPORTING iv_tabname   = 'TDEVC'
                         iv_fieldname = 'INTSYS'
                         iv_fieldtext = 'Folder logic'
                         iv_value     = 'PREFIX'
               CHANGING  ct_fields    = lt_fields ).

    TRY.

        _popup_2_get_values( EXPORTING iv_popup_title    = 'Export package' ""#EC NOTEXT
                                       iv_no_value_check = abap_true
                             IMPORTING ev_value_1        = lv_package
                                       ev_value_2        = lv_folder_logic
                             CHANGING  ct_fields         = lt_fields ).

        ev_package = to_upper( lv_package ).
        ev_folder_logic = to_upper( lv_folder_logic ).

      CATCH zcx_abapgit_cancel.
    ENDTRY.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_to_confirm.

    CALL FUNCTION 'POPUP_TO_CONFIRM'
      EXPORTING
        titlebar              = iv_titlebar
        text_question         = iv_text_question
        text_button_1         = iv_text_button_1
        icon_button_1         = iv_icon_button_1
        text_button_2         = iv_text_button_2
        icon_button_2         = iv_icon_button_2
        default_button        = iv_default_button
        display_cancel_button = iv_display_cancel_button
      IMPORTING
        answer                = rv_answer
      EXCEPTIONS
        text_not_found        = 1
        OTHERS                = 2.                        ""#EC NOTEXT
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from POPUP_TO_CONFIRM' ).
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_to_create_package.
    CALL FUNCTION 'FUNCTION_EXISTS'
      EXPORTING
        funcname           = 'PB_POPUP_PACKAGE_CREATE'
      EXCEPTIONS
        function_not_exist = 1
        OTHERS             = 2.
    IF sy-subrc = 1.
* looks like the function module used does not exist on all
* versions since 702, so show an error
      zcx_abapgit_exception=>raise( 'Your system does not support automatic creation of packages.' &&
        'Please, create the package manually.' ).
    ENDIF.

    CALL FUNCTION 'PB_POPUP_PACKAGE_CREATE'
      CHANGING
        p_object_data    = es_package_data
      EXCEPTIONS
        action_cancelled = 1.
    IF sy-subrc = 0.
      ev_create = abap_true.
    ELSE.
      ev_create = abap_false.
    ENDIF.
  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_to_create_transp_branch.
    DATA: lt_fields             TYPE TABLE OF sval,
          lv_transports_as_text TYPE string,
          lv_desc_as_text       TYPE string,
          ls_transport_header   LIKE LINE OF it_transport_headers.
    DATA: lv_branch_name        TYPE spo_value.
    DATA: lv_commit_text        TYPE spo_value.

    CLEAR: rs_transport_branch-branch_name, rs_transport_branch-commit_text.

    "" If we only have one transport selected set branch name to Transport
    "" name and commit description to transport description.
    IF lines( it_transport_headers ) = 1.
      READ TABLE it_transport_headers INDEX 1 INTO ls_transport_header.
      lv_transports_as_text = ls_transport_header-trkorr.
      SELECT SINGLE as4text FROM e07t INTO lv_desc_as_text  WHERE
        trkorr = ls_transport_header-trkorr AND
        langu = sy-langu.
    ELSE.   "" Else set branch name and commit message to 'Transport(s)_TRXXXXXX_TRXXXXX'
      lv_transports_as_text = 'Transport(s)'.
      LOOP AT it_transport_headers INTO ls_transport_header.
        CONCATENATE lv_transports_as_text '_' ls_transport_header-trkorr INTO lv_transports_as_text.
      ENDLOOP.
      lv_desc_as_text = lv_transports_as_text.

    ENDIF.
    add_field( EXPORTING iv_tabname   = 'TEXTL'
                         iv_fieldname = 'LINE'
                         iv_fieldtext = 'Branch name'
                         iv_value     = lv_transports_as_text
               CHANGING ct_fields     = lt_fields ).

    add_field( EXPORTING iv_tabname   = 'ABAPTXT255'
                         iv_fieldname = 'LINE'
                         iv_fieldtext = 'Commit text'
                         iv_value     = lv_desc_as_text
               CHANGING ct_fields     = lt_fields ).

    _popup_2_get_values( EXPORTING iv_popup_title    = 'Transport to new Branch' ""#EC NOTEXT
                         IMPORTING ev_value_1        = lv_branch_name
                                   ev_value_2        = lv_commit_text
                         CHANGING  ct_fields         = lt_fields ).

    rs_transport_branch-branch_name = lv_branch_name.
    rs_transport_branch-commit_text = lv_commit_text.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_to_inform.

    DATA: lv_line1 TYPE char70,
          lv_line2 TYPE char70.

    lv_line1 = iv_text_message.
    IF strlen( iv_text_message ) > 70.
      lv_line2 = iv_text_message+70.
    ENDIF.

    CALL FUNCTION 'POPUP_TO_INFORM'
      EXPORTING
        titel = iv_titlebar
        txt1  = lv_line1
        txt2  = lv_line2.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_to_select_from_list.

    DATA:
      lo_events       TYPE REF TO cl_salv_events_table,
      lo_columns      TYPE REF TO cl_salv_columns_table,
      lt_columns      TYPE salv_t_column_ref,
      ls_column       TYPE salv_s_column_ref,
      lo_column       TYPE REF TO cl_salv_column_list,
      lo_table_header TYPE REF TO cl_salv_form_text.

    FIELD-SYMBOLS: <lt_table> TYPE STANDARD TABLE.

    CLEAR: et_list.

    create_new_table( it_list ).

    ASSIGN mr_table->* TO <lt_table>.
    ASSERT sy-subrc = 0.

    TRY.
        cl_salv_table=>factory( IMPORTING r_salv_table = mo_select_list_popup
                                CHANGING  t_table = <lt_table> ).

        mo_select_list_popup->set_screen_status( pfstatus = '102'
                                                 report = 'SAPMSVIM' ).

        mo_select_list_popup->set_screen_popup( start_column = 1
                                                end_column   = 65
                                                start_line   = 1
                                                end_line     = 20 ).

        lo_events = mo_select_list_popup->get_event( ).

        SET HANDLER on_select_list_link_click FOR lo_events.
        SET HANDLER on_select_list_function_click FOR lo_events.

        CREATE OBJECT lo_table_header
          EXPORTING
            text = iv_header_text.

        mo_select_list_popup->set_top_of_list( lo_table_header ).

        lo_columns = mo_select_list_popup->get_columns( ).
        lo_columns->set_optimize( abap_true ).
        lt_columns = lo_columns->get( ).

        LOOP AT lt_columns INTO ls_column.

          IF ls_column-columnname = c_fieldname_selected.
            lo_column ?= ls_column-r_column.
            lo_column->set_cell_type( if_salv_c_cell_type=>checkbox_hotspot ).
            lo_column->set_output_length( 20 ).
            lo_column->set_short_text( |{ iv_select_column_text }| ).
            lo_column->set_medium_text( |{ iv_select_column_text }| ).
            lo_column->set_long_text( |{ iv_select_column_text }| ).
            CONTINUE.
          ENDIF.

          READ TABLE it_columns_to_display TRANSPORTING NO FIELDS
                                           WITH KEY table_line = ls_column-columnname.
          IF sy-subrc <> 0.
            ls_column-r_column->set_technical( abap_true ).
          ENDIF.

        ENDLOOP.

        mo_select_list_popup->display( ).

      CATCH cx_salv_msg.
        zcx_abapgit_exception=>raise( 'Error from POPUP_TO_SELECT_FROM_LIST' ).
    ENDTRY.

    IF mv_cancel = abap_true.
      RAISE EXCEPTION TYPE zcx_abapgit_cancel.
    ENDIF.

    get_selected_rows(
      IMPORTING
        et_list = et_list ).

    CLEAR: mo_select_list_popup,
           mr_table,
           mo_table_descr.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_to_select_transports.

* todo, method to be renamed, it only returns one transport

    DATA: lv_trkorr TYPE e070-trkorr,
          ls_trkorr LIKE LINE OF rt_trkorr.


    CALL FUNCTION 'TR_F4_REQUESTS'
      IMPORTING
        ev_selected_request = lv_trkorr.

    IF NOT lv_trkorr IS INITIAL.
      ls_trkorr-trkorr = lv_trkorr.
      APPEND ls_trkorr TO rt_trkorr.
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~popup_transport_request.

    DATA: lt_e071  TYPE STANDARD TABLE OF e071,
          lt_e071k TYPE STANDARD TABLE OF e071k.

    CALL FUNCTION 'TRINT_ORDER_CHOICE'
      EXPORTING
        wi_order_type          = is_transport_type-request
        wi_task_type           = is_transport_type-task
      IMPORTING
        we_order               = rv_transport
      TABLES
        wt_e071                = lt_e071
        wt_e071k               = lt_e071k
      EXCEPTIONS
        no_correction_selected = 1
        display_mode           = 2
        object_append_error    = 3
        recursive_call         = 4
        wrong_order_type       = 5
        OTHERS                 = 6.

    IF sy-subrc = 1.
      RAISE EXCEPTION TYPE zcx_abapgit_cancel.
    ELSEIF sy-subrc > 1.
      zcx_abapgit_exception=>raise( |Error from TRINT_ORDER_CHOICE { sy-subrc }| ).
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_popups~repo_new_offline.

    DATA: lv_returncode TYPE c,
          lt_fields     TYPE TABLE OF sval,
          lv_icon_ok    TYPE icon-name,
          lv_button1    TYPE svalbutton-buttontext,
          lv_icon1      TYPE icon-name,
          lv_finished   TYPE abap_bool,
          lx_error      TYPE REF TO zcx_abapgit_exception.

    FIELD-SYMBOLS: <ls_field> LIKE LINE OF lt_fields.


    add_field( EXPORTING iv_tabname    = 'ABAPTXT255'
                         iv_fieldname  = 'LINE'
                         iv_fieldtext  = 'Name'
                         iv_obligatory = abap_true
               CHANGING  ct_fields     = lt_fields ).

    add_field( EXPORTING iv_tabname    = 'TDEVC'
                         iv_fieldname  = 'DEVCLASS'
                         iv_fieldtext  = 'Package'
                         iv_obligatory = abap_true
               CHANGING  ct_fields     = lt_fields ).

    add_field( EXPORTING iv_tabname    = 'ZABAPGIT'
                         iv_fieldname  = 'VALUE'
                         iv_fieldtext  = 'Folder logic'
                         iv_obligatory = abap_true
                         iv_value      = zif_abapgit_dot_abapgit=>c_folder_logic-prefix
               CHANGING  ct_fields     = lt_fields ).

    WHILE lv_finished = abap_false.

      lv_icon_ok  = icon_okay.
      lv_button1 = 'Create package' ##NO_TEXT.
      lv_icon1   = icon_folder.

      CALL FUNCTION 'POPUP_GET_VALUES_USER_BUTTONS'
        EXPORTING
          popup_title       = 'New Offline Project'
          programname       = sy-cprog
          formname          = 'PACKAGE_POPUP'
          ok_pushbuttontext = 'OK'
          icon_ok_push      = lv_icon_ok
          first_pushbutton  = lv_button1
          icon_button_1     = lv_icon1
          second_pushbutton = ''
          icon_button_2     = ''
        IMPORTING
          returncode        = lv_returncode
        TABLES
          fields            = lt_fields
        EXCEPTIONS
          error_in_fields   = 1
          OTHERS            = 2.
      IF sy-subrc <> 0.
        zcx_abapgit_exception=>raise( 'Error from POPUP_GET_VALUES' ).
      ENDIF.

      IF lv_returncode = c_answer_cancel.
        rs_popup-cancel = abap_true.
        RETURN.
      ENDIF.

      READ TABLE lt_fields INDEX 1 ASSIGNING <ls_field>.
      ASSERT sy-subrc = 0.
      rs_popup-url = <ls_field>-value.

      READ TABLE lt_fields INDEX 2 ASSIGNING <ls_field>.
      ASSERT sy-subrc = 0.
      TRANSLATE <ls_field>-value TO UPPER CASE.
      rs_popup-package = <ls_field>-value.

      READ TABLE lt_fields INDEX 3 ASSIGNING <ls_field>.
      ASSERT sy-subrc = 0.
      TRANSLATE <ls_field>-value TO UPPER CASE.
      rs_popup-folder_logic = <ls_field>-value.

      lv_finished = abap_true.

      TRY.
          zcl_abapgit_repo_srv=>get_instance( )->validate_package( rs_popup-package ).
          validate_folder_logic( rs_popup-folder_logic ).

        CATCH zcx_abapgit_exception INTO lx_error.
          "" in case of validation errors we display the popup again
          MESSAGE lx_error TYPE 'S' DISPLAY LIKE 'E'.
          CLEAR lv_finished.
      ENDTRY.

    ENDWHILE.

  ENDMETHOD.


  METHOD zif_abapgit_popups~repo_popup.

    DATA: lv_returncode   TYPE c,
          lv_icon_ok      TYPE icon-name,
          lv_icon_br      TYPE icon-name,
          lt_fields       TYPE TABLE OF sval,
          lv_uattr        TYPE spo_fattr,
          lv_pattr        TYPE spo_fattr,
          lv_button2      TYPE svalbutton-buttontext,
          lv_icon2        TYPE icon-name,
          lv_package      TYPE tdevc-devclass,
          lv_url          TYPE abaptxt255-line,
          lv_branch       TYPE textl-line,
          lv_display_name TYPE trm255-text,
          lv_folder_logic TYPE string,
          lv_ign_subpkg   TYPE abap_bool,
          lv_finished     TYPE abap_bool,
          lx_error        TYPE REF TO zcx_abapgit_exception.

    IF iv_freeze_url = abap_true.
      lv_uattr = '05'.
    ENDIF.

    IF iv_freeze_package = abap_true.
      lv_pattr = '05'.
    ENDIF.

    IF iv_package IS INITIAL. "" Empty package -> can be created
      lv_button2 = 'Create package' ##NO_TEXT.
      lv_icon2   = icon_folder.
    ENDIF.

    lv_display_name = iv_display_name.
    lv_package = iv_package.
    lv_url     = iv_url.
    lv_branch  = iv_branch.

    WHILE lv_finished = abap_false.

      CLEAR: lt_fields.

      add_field( EXPORTING iv_tabname    = 'ABAPTXT255'
                           iv_fieldname  = 'LINE'
                           iv_fieldtext  = 'Git clone URL'
                           iv_value      = lv_url
                           iv_field_attr = lv_uattr
                 CHANGING ct_fields      = lt_fields ).

      add_field( EXPORTING iv_tabname    = 'TDEVC'
                           iv_fieldname  = 'DEVCLASS'
                           iv_fieldtext  = 'Package'
                           iv_value      = lv_package
                           iv_field_attr = lv_pattr
                 CHANGING ct_fields      = lt_fields ).

      add_field( EXPORTING iv_tabname    = 'TEXTL'
                           iv_fieldname  = 'LINE'
                           iv_fieldtext  = 'Branch'
                           iv_value      = lv_branch
                           iv_field_attr = '05'
                 CHANGING ct_fields      = lt_fields ).

      add_field( EXPORTING iv_tabname    = 'TRM255'
                           iv_fieldname  = 'TEXT'
                           iv_fieldtext  = 'Display name (opt.)'
                           iv_value      = lv_display_name
                 CHANGING ct_fields      = lt_fields ).

      add_field( EXPORTING iv_tabname    = 'ZABAPGIT'
                           iv_fieldname  = 'VALUE'
                           iv_fieldtext  = 'Folder logic'
                           iv_obligatory = abap_true
                           iv_value      = zif_abapgit_dot_abapgit=>c_folder_logic-prefix
                 CHANGING ct_fields      = lt_fields ).

      add_field( EXPORTING iv_tabname    = 'TDEVC'
                           iv_fieldname  = 'IS_ENHANCEABLE'
                           iv_fieldtext  = 'Ignore subpackages'
                           iv_value      = abap_false
                 CHANGING ct_fields      = lt_fields ).

      lv_icon_ok  = icon_okay.
      lv_icon_br  = icon_workflow_fork.

      CALL FUNCTION 'POPUP_GET_VALUES_USER_BUTTONS'
        EXPORTING
          popup_title       = iv_title
          programname       = sy-cprog
          formname          = 'BRANCH_POPUP'
          ok_pushbuttontext = 'OK'
          icon_ok_push      = lv_icon_ok
          first_pushbutton  = 'Select branch'
          icon_button_1     = lv_icon_br
          second_pushbutton = lv_button2
          icon_button_2     = lv_icon2
        IMPORTING
          returncode        = lv_returncode
        TABLES
          fields            = lt_fields
        EXCEPTIONS
          error_in_fields   = 1
          OTHERS            = 2.                              ""#EC NOTEXT

      IF sy-subrc <> 0.
        zcx_abapgit_exception=>raise( 'Error from POPUP_GET_VALUES' ).
      ENDIF.

      IF lv_returncode = c_answer_cancel.
        rs_popup-cancel = abap_true.
        RETURN.
      ENDIF.

      extract_field_values(
        EXPORTING
          it_fields       = lt_fields
        IMPORTING
          ev_url          = lv_url
          ev_package      = lv_package
          ev_branch       = lv_branch
          ev_display_name = lv_display_name
          ev_folder_logic = lv_folder_logic
          ev_ign_subpkg   = lv_ign_subpkg ).

      lv_finished = abap_true.

      TRY.
          zcl_abapgit_url=>validate( |{ lv_url }| ).
          IF iv_freeze_package = abap_false.
            zcl_abapgit_repo_srv=>get_instance( )->validate_package( iv_package    = lv_package
                                                                     iv_ign_subpkg = lv_ign_subpkg ).
          ENDIF.
          validate_folder_logic( lv_folder_logic ).
        CATCH zcx_abapgit_exception INTO lx_error.
          MESSAGE lx_error TYPE 'S' DISPLAY LIKE 'E'.
          "" in case of validation errors we display the popup again
          CLEAR lv_finished.
      ENDTRY.

    ENDWHILE.

    rs_popup-url          = lv_url.
    rs_popup-package      = lv_package.
    rs_popup-branch_name  = lv_branch.
    rs_popup-display_name = lv_display_name.
    rs_popup-folder_logic = lv_folder_logic.
    rs_popup-ign_subpkg   = lv_ign_subpkg.

  ENDMETHOD.


  METHOD zif_abapgit_popups~run_page_class_popup.

    DATA: lt_fields TYPE TABLE OF sval.
    DATA: lv_name   TYPE spo_value.

    CLEAR: ev_name, ev_cancel.

    add_field( EXPORTING iv_tabname   = 'TEXTL'
                         iv_fieldname = 'LINE'
                         iv_fieldtext = 'Name'
                         iv_value     = 'lcl_gui_page_'
               CHANGING  ct_fields    = lt_fields ).

    TRY.

        _popup_2_get_values( EXPORTING iv_popup_title = 'Run page manually' ""#EC NOTEXT
                             IMPORTING ev_value_1     = lv_name
                             CHANGING ct_fields       = lt_fields ).

        ev_name = to_upper( lv_name ).

      CATCH zcx_abapgit_cancel.
        ev_cancel = abap_true.
    ENDTRY.

  ENDMETHOD.


  METHOD _popup_2_get_values.

    DATA lv_answer TYPE char1.
    FIELD-SYMBOLS: <ls_field> TYPE sval.

    CALL FUNCTION 'POPUP_GET_VALUES'
      EXPORTING
        no_value_check = iv_no_value_check
        popup_title    = iv_popup_title
      IMPORTING
        returncode     = lv_answer
      TABLES
        fields         = ct_fields
      EXCEPTIONS
        OTHERS         = 1 ##NO_TEXT.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'Error from POPUP_GET_VALUES' ).
    ENDIF.

    IF lv_answer = c_answer_cancel.
      RAISE EXCEPTION TYPE zcx_abapgit_cancel.
    ENDIF.

    IF ev_value_1 IS SUPPLIED.
      READ TABLE ct_fields INDEX 1 ASSIGNING <ls_field>.
      ASSERT sy-subrc = 0.
      ev_value_1 = <ls_field>-value.
    ENDIF.

    IF ev_value_2 IS SUPPLIED.
      READ TABLE ct_fields INDEX 2 ASSIGNING <ls_field>.
      ASSERT sy-subrc = 0.
      ev_value_2 = <ls_field>-value.
    ENDIF.

  ENDMETHOD.
ENDCLASS.
",9622,False,2052.6870799689127,median
"// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <limits.h>
#include <stddef.h>
#include <stdint.h>

#include <crypto/aead.h>
#include <crypto/bytes.h>
#include <crypto/secret.h>
#include <unittest/unittest.h>
#include <zircon/errors.h>
#include <zircon/types.h>

#include ""utils.h""

namespace crypto {
namespace testing {
namespace {

// See utils.h; the following macros allow reusing tests for each of the supported AEADs.
#define EACH_PARAM(OP, Test)                                                                       \\
    OP(Test, AEAD, AES128_GCM)                                                                     \\
    OP(Test, AEAD, AES128_GCM_SIV)

bool TestGetLengths_Uninitialized(void) {
    size_t key_len;
    EXPECT_ZX(AEAD::GetKeyLen(AEAD::kUninitialized, &key_len), ZX_ERR_INVALID_ARGS);

    size_t iv_len;
    EXPECT_ZX(AEAD::GetIVLen(AEAD::kUninitialized, &iv_len), ZX_ERR_INVALID_ARGS);
    END_TEST;
}

bool TestGetLengths_AES128_GCM(void) {
    size_t key_len;
    EXPECT_ZX(AEAD::GetKeyLen(AEAD::kAES128_GCM, nullptr), ZX_ERR_INVALID_ARGS);
    EXPECT_OK(AEAD::GetKeyLen(AEAD::kAES128_GCM, &key_len));
    EXPECT_EQ(key_len, 16U);

    size_t iv_len;
    EXPECT_ZX(AEAD::GetIVLen(AEAD::kAES128_GCM, nullptr), ZX_ERR_INVALID_ARGS);
    EXPECT_OK(AEAD::GetIVLen(AEAD::kAES128_GCM, &iv_len));
    EXPECT_EQ(iv_len, 12U);

    size_t tag_len;
    EXPECT_ZX(AEAD::GetTagLen(AEAD::kAES128_GCM, nullptr), ZX_ERR_INVALID_ARGS);
    EXPECT_OK(AEAD::GetTagLen(AEAD::kAES128_GCM, &tag_len));
    EXPECT_EQ(tag_len, 16U);
    END_TEST;
}

bool TestGetLengths_AES128_GCM_SIV(void) {
    size_t key_len;
    EXPECT_ZX(AEAD::GetKeyLen(AEAD::kAES128_GCM_SIV, nullptr), ZX_ERR_INVALID_ARGS);
    EXPECT_OK(AEAD::GetKeyLen(AEAD::kAES128_GCM_SIV, &key_len));
    EXPECT_EQ(key_len, 16U);

    size_t iv_len;
    EXPECT_ZX(AEAD::GetIVLen(AEAD::kAES128_GCM_SIV, nullptr), ZX_ERR_INVALID_ARGS);
    EXPECT_OK(AEAD::GetIVLen(AEAD::kAES128_GCM_SIV, &iv_len));
    EXPECT_EQ(iv_len, 12U);

    size_t tag_len;
    EXPECT_ZX(AEAD::GetTagLen(AEAD::kAES128_GCM_SIV, nullptr), ZX_ERR_INVALID_ARGS);
    EXPECT_OK(AEAD::GetTagLen(AEAD::kAES128_GCM_SIV, &tag_len));
    EXPECT_EQ(tag_len, 16U);
    END_TEST;
}

bool TestInitSeal_Uninitialized(void) {
    BEGIN_TEST;
    AEAD sealer;
    Secret key;
    Bytes iv;
    EXPECT_ZX(sealer.InitSeal(AEAD::kUninitialized, key, iv), ZX_ERR_INVALID_ARGS);
    END_TEST;
}

bool TestInitSeal(AEAD::Algorithm aead) {
    BEGIN_TEST;
    AEAD sealer;
    Secret key;
    Bytes iv;
    ASSERT_OK(GenerateKeyMaterial(aead, &key, &iv));

    // Bad key
    Secret bad_key;
    ASSERT_OK(bad_key.Generate(key.len() - 1));
    EXPECT_ZX(sealer.InitSeal(aead, bad_key, iv), ZX_ERR_INVALID_ARGS);

    // Bad IV
    Bytes bad_iv;
    ASSERT_OK(iv.Copy(iv.get(), iv.len() - 1));
    EXPECT_ZX(sealer.InitSeal(aead, key, bad_iv), ZX_ERR_INVALID_ARGS);

    // Valid
    EXPECT_OK(sealer.InitSeal(aead, key, iv));

    END_TEST;
}
DEFINE_EACH(TestInitSeal)

bool TestInitOpen_Uninitialized(void) {
    BEGIN_TEST;
    AEAD opener;
    Secret key;
    Bytes iv;
    EXPECT_ZX(opener.InitOpen(AEAD::kUninitialized, key, iv), ZX_ERR_INVALID_ARGS);
    END_TEST;
}

bool TestInitOpen(AEAD::Algorithm aead) {
    BEGIN_TEST;
    AEAD opener;
    Secret key;
    Bytes iv;
    ASSERT_OK(GenerateKeyMaterial(aead, &key, &iv));

    // Bad key
    Secret bad_key;
    ASSERT_OK(bad_key.Generate(key.len() - 1));
    EXPECT_ZX(opener.InitOpen(aead, bad_key, iv), ZX_ERR_INVALID_ARGS);

    // Bad IV
    Bytes bad_iv;
    ASSERT_OK(bad_iv.Copy(iv.get(), iv.len() - 1));
    EXPECT_ZX(opener.InitOpen(aead, key, bad_iv), ZX_ERR_INVALID_ARGS);

    // Valid
    EXPECT_OK(opener.InitOpen(aead, key, iv));

    END_TEST;
}
DEFINE_EACH(TestInitOpen)

bool TestSealData(AEAD::Algorithm aead) {
    BEGIN_TEST;
    AEAD sealer;
    Secret key;
    Bytes iv, ptext, ctext;
    uint64_t nonce;
    ASSERT_OK(GenerateKeyMaterial(aead, &key, &iv));
    ASSERT_OK(ptext.Randomize(PAGE_SIZE));

    // Not initialized
    EXPECT_ZX(sealer.Seal(ptext, &nonce, &ctext), ZX_ERR_BAD_STATE);
    ASSERT_OK(sealer.InitSeal(aead, key, iv));

    // Missing parameters
    EXPECT_ZX(sealer.Seal(ptext, nullptr, &ctext), ZX_ERR_INVALID_ARGS);
    EXPECT_ZX(sealer.Seal(ptext, &nonce, nullptr), ZX_ERR_INVALID_ARGS);

    // Wrong mode
    EXPECT_ZX(sealer.Open(nonce, ctext, &ptext), ZX_ERR_BAD_STATE);

    // Valid
    EXPECT_OK(sealer.Seal(ptext, &nonce, &ctext));
    ASSERT_OK(ptext.Resize(0));
    EXPECT_OK(sealer.Seal(ptext, &nonce, &ctext));

    // Reset
    sealer.Reset();
    EXPECT_ZX(sealer.Seal(ptext, &nonce, &ctext), ZX_ERR_BAD_STATE);
    END_TEST;
}
DEFINE_EACH(TestSealData)

bool TestOpenData(AEAD::Algorithm aead) {
    BEGIN_TEST;
    Secret key;
    Bytes iv, ptext, ctext, result;
    uint64_t nonce = 0;
    ASSERT_OK(GenerateKeyMaterial(aead, &key, &iv));
    ASSERT_OK(ptext.Randomize(PAGE_SIZE));

    AEAD sealer;
    ASSERT_OK(sealer.InitSeal(aead, key, iv));
    // ASSERT_OK(sealer.Seal(ptext, &nonce, &ctext));

    // Not initialized
    AEAD opener;
    EXPECT_ZX(opener.Open(nonce, ctext, &result), ZX_ERR_BAD_STATE);
    ASSERT_OK(opener.InitOpen(aead, key, iv));

    // Missing parameters
    EXPECT_ZX(opener.Open(nonce, ctext, nullptr), ZX_ERR_INVALID_ARGS);

    // Wrong IV
    ASSERT_OK(sealer.Seal(ptext, &nonce, &ctext));
    EXPECT_ZX(opener.Open(nonce + 1, ctext, &result), ZX_ERR_IO_DATA_INTEGRITY);

    // Wrong tag
    size_t len;
    ASSERT_OK(AEAD::GetTagLen(aead, &len));
    ASSERT_OK(ctext.Resize(len - 1));
    EXPECT_ZX(opener.Open(nonce, ctext, &result), ZX_ERR_INVALID_ARGS);

    ASSERT_OK(ctext.Resize(0));
    ASSERT_OK(sealer.Seal(ptext, &nonce, &ctext));
    len = ctext.len();
    ctext[len - 1] ^= 1;
    EXPECT_ZX(opener.Open(nonce, ctext, &result), ZX_ERR_IO_DATA_INTEGRITY);
    ctext[len - 1] ^= 1;

    // Wrong data
    ctext[0] ^= 1;
    EXPECT_ZX(opener.Open(nonce, ctext, &result), ZX_ERR_IO_DATA_INTEGRITY);
    ctext[0] ^= 1;

    // Wrong mode
    EXPECT_ZX(opener.Seal(ptext, &nonce, &ctext), ZX_ERR_BAD_STATE);

    // Valid
    ASSERT_OK(sealer.Seal(ptext, &nonce, &ctext));
    EXPECT_OK(opener.Open(nonce, ctext, &result));

    ASSERT_OK(sealer.Seal(ptext, &nonce, &ctext));
    EXPECT_OK(opener.Open(nonce, ctext, &result));
    EXPECT_TRUE(ptext == result);

    // Reset
    opener.Reset();
    EXPECT_ZX(opener.Open(nonce, ctext, &result), ZX_ERR_BAD_STATE);
    END_TEST;
}
DEFINE_EACH(TestOpenData)

// The following tests are taken from NIST's SP 800-38D.  The tests with non-byte non-standard IV
// and tag lengths are omitted.  Of those remaining, the first non-failing test of each combination
// of text and AAD length is selected as a representative sample.
bool TestAes128Gcm_TC(const char* xkey, const char* xiv, const char* xct, const char* xaad,
                      const char* xtag, const char* xpt) {
    BEGIN_TEST;
    Secret key;
    Bytes ptext, aad, iv, ctext, tag, result;
    uint64_t nonce;
    ASSERT_OK(HexToSecret(xkey, &key));
    ASSERT_OK(HexToBytes(xiv, &iv));
    ASSERT_OK(HexToBytes(xct, &ctext));
    ASSERT_OK(HexToBytes(xaad, &aad));
    ASSERT_OK(HexToBytes(xtag, &tag));
    ASSERT_OK(HexToBytes(xpt, &ptext));
    ASSERT_OK(ctext.Copy(tag.get(), tag.len(), ctext.len()));

    AEAD sealer;
    EXPECT_OK(sealer.InitSeal(AEAD::kAES128_GCM, key, iv));
    EXPECT_OK(sealer.Seal(ptext, aad, &nonce, &result));
    EXPECT_TRUE(result == ctext);

    ASSERT_OK(result.Resize(0));
    AEAD opener;
    EXPECT_OK(opener.InitOpen(AEAD::kAES128_GCM, key, iv));
    EXPECT_OK(opener.Open(nonce, ctext, aad, &result));
    EXPECT_TRUE(result == ptext);
    END_TEST;
}

// clang-format off
bool TestAes128Gcm_TC01(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""cf063a34d4a9a76c2c86787d3f96db71"",
        /* IV */  ""113b9785971864c83b01c787"",
        /* CT */  """",
        /* AAD */ """",
        /* Tag */ ""72ac8493e3a5228b5d130a69d2510e42"",
        /* PT */  """");
}

bool TestAes128Gcm_TC02(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""e98b72a9881a84ca6b76e0f43e68647a"",
        /* IV */  ""8b23299fde174053f3d652ba"",
        /* CT */  ""5a3c1cf1985dbb8bed818036fdd5ab42"",
        /* AAD */ """",
        /* Tag */ ""23c7ab0f952b7091cd324835043b5eb5"",
        /* PT */  ""28286a321293253c3e0aa2704a278032"");
}

bool TestAes128Gcm_TC03(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""816e39070410cf2184904da03ea5075a"",
        /* IV */  ""32c367a3362613b27fc3e67e"",
        /* CT */  ""552ebe012e7bcf90fcef712f8344e8f1"",
        /* AAD */ ""f2a30728ed874ee02983c294435d3c16"",
        /* Tag */ ""ecaae9fc68276a45ab0ca3cb9dd9539f"",
        /* PT */  ""ecafe96c67a1646744f1c891f5e69427"");
}

bool TestAes128Gcm_TC04(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""d9529840200e1c17725ab52c9c927637"",
        /* IV */  ""6e9a639d4aecc25530a8ad75"",
        /* CT */  ""6c779895e78179783c51ade1926436b9"",
        /* AAD */ ""472a6f4e7771ca391e42065030db3ff418f3b636"",
        /* Tag */ ""4522bfdef4a635a38db5784b27d43661"",
        /* PT */  ""8ae823895ee4e7f08bc8bad04d63c220"");
}

bool TestAes128Gcm_TC05(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""abbc49ee0bbe3d81afc2b6b84f70b748"",
        /* IV */  ""f11db9f7b99a59ed59ade66f"",
        /* CT */  ""ce2d76f834942c022044eebc91b461c0"",
        /* AAD */ ""d533cf7644a48da46fcdec47ae5c77b9b52db775d6c886896e4f4e00c51affd59499a0e572f324989df511c4ea5f93cd"",
        /* Tag */ ""62df4b04f219554cd3e69d3c870032d2"",
        /* PT */  ""5135ba1354cbb80478ecaf3db38a443f"");
}

bool TestAes128Gcm_TC06(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""300b8ffab4368cc90f6d4063e4279f2a"",
        /* IV */  ""8e69fa64e871d0e98a183a49"",
        /* CT */  ""2d2292da61c280aff86767d25b75e814"",
        /* AAD */ ""5166309e153447b27c67051453abf441de3f4a7f6b633ec6122ff82dc132cfb422d36c5ec6e7cc90a9ad55caa1ccdcb82dc5022a20062a9c6e9238f34d085b1f554b5eac05eff25b5a5cb6e18e7827d70175dc0662d77033d118"",
        /* Tag */ ""633ee657a8981a7682f87505594c95ad"",
        /* PT */  ""4953b54859870631e818da71fc69c981"");
}

bool TestAes128Gcm_TC07(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""387218b246c1a8257748b56980e50c94"",
        /* IV */  ""dd7e014198672be39f95b69d"",
        /* CT */  ""cdba9e73eaf3d38eceb2b04a8d"",
        /* AAD */ """",
        /* Tag */ ""ecf90f4a47c9c626d6fb2c765d201556"",
        /* PT */  ""48f5b426baca03064554cc2b30"");
}

bool TestAes128Gcm_TC08(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""660eb76f3d8b6ec54e01b8a36263124b"",
        /* IV */  ""3d8cf16e262880ddfe0c86eb"",
        /* CT */  ""b1ee05f1415a61d7637e97c5f3"",
        /* AAD */ ""8560b10c011a1d4190eb46a3692daa17"",
        /* Tag */ ""761cb84a963e1db1a4ab2c5f904c09db"",
        /* PT */  ""2efbaedfec3cfe4ac32f201fa5"");
}

bool TestAes128Gcm_TC09(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""c62dc36b9230e739179f3c58e7270ff9"",
        /* IV */  ""196a0572d8ff2fbd3522b6a5"",
        /* CT */  ""958062b331f05b3acaa1836fc2"",
        /* AAD */ ""4d10536cbdbd6f1d38b2bd10ab8c1c29ae68138e"",
        /* Tag */ ""dc65a20d9a9aec2e7699eaead47afb42"",
        /* PT */  ""6d8abcee45667e7a9443896cbf"");
}

bool TestAes128Gcm_TC10(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""ef1da9dd794219ebf8f717d5a98ab0af"",
        /* IV */  ""3f3983dc63986e33d1b6bffc"",
        /* CT */  ""95ea05701481e915c72446c876"",
        /* AAD */ ""5abd0c1c52b687e9a1673b69137895e5025c2bd18cbeacdb9472e918fe1587da558c492cc708d270fd10572eea83d2de"",
        /* Tag */ ""5c866992662005ca8886810e278c8ab4"",
        /* PT */  ""5511872905436c7de38e9501e7"");
}

bool TestAes128Gcm_TC11(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""77b55a5b37690c9b1b01a05820838e3e"",
        /* IV */  ""7a8e0d881f023a9954941037"",
        /* CT */  ""e0eb3359e443e1108ed4068969"",
        /* AAD */ ""0bb1ad1d294b927c24ee097d0a9afbaa6a62c8923627b50bd96e5ba852509a2e76f7a10ee3987e37a55b92d08531897e6cd76462403b39fb31508cc9fc7684ab5ec2ccc73e8a7f4104a277319bf207fcf263eceed13a76ca177f"",
        /* Tag */ ""ea6383077d15d7d0a97220848a7616a9"",
        /* PT */  ""d164aeccec7dbcadee4f41b6a9"");
}

bool TestAes128Gcm_TC12(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""bfd414a6212958a607a0f5d3ab48471d"",
        /* IV */  ""86d8ea0ab8e40dcc481cd0e2"",
        /* CT */  ""62171db33193292d930bf6647347652c1ef33316d7feca99d54f1db4fcf513f8"",
        /* AAD */ """",
        /* Tag */ ""c28280aa5c6c7a8bd366f28c1cfd1f6e"",
        /* PT */  ""a6b76a066e63392c9443e60272ceaeb9d25c991b0f2e55e2804e168c05ea591a"");
}

bool TestAes128Gcm_TC13(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""95bcde70c094f04e3dd8259cafd88ce8"",
        /* IV */  ""12cf097ad22380432ff40a5c"",
        /* CT */  ""8a023ba477f5b809bddcda8f55e09064d6d88aaec99c1e141212ea5b08503660"",
        /* AAD */ ""c783a0cca10a8d9fb8d27d69659463f2"",
        /* Tag */ ""562f500dae635d60a769b466e15acd1e"",
        /* PT */  ""32f51e837a9748838925066d69e87180f34a6437e6b396e5643b34cb2ee4f7b1"");
}

bool TestAes128Gcm_TC14(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""f3e60720c7eff3af96a0e7b2a359c322"",
        /* IV */  ""8c9cb6af794f8c0fc4c8c06e"",
        /* CT */  ""73e308d968ead96cefc9337dea6952ac3afbe39d7d14d063b9f59ab89c3f6acc"",
        /* AAD */ ""5d15b60acc008f9308731ea0a3098644866fa862"",
        /* Tag */ ""658e311f9c9816dbf2567f811e905ab8"",
        /* PT */  ""7e299a25404311ee29eee9349f1e7f876dca42ba81f44295bb9b3a152a27a2af"");
}

bool TestAes128Gcm_TC15(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""8453cf505f22445634b18680c1f6b0f3"",
        /* IV */  ""fab8e5ce90102286182ef690"",
        /* CT */  ""5475442af3ba2bd865ae082bc5e92ad7f42cd84b8c64daadcf18f0d4863b6172"",
        /* AAD */ ""ff76d2210f2caec37490a19352c3945be1c5facb89cb3e9947754cade47ec932d95c88d7d2299a8b6db76b5144ab9516"",
        /* Tag */ ""972a7e85787ba26c626db1a1e7c13acb"",
        /* PT */  ""e4abb4773f5cc51c9df6322612d75f70696c17733ce41e22427250ae61fd90d3"");
}

bool TestAes128Gcm_TC16(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""07a6be880a58f572dbc2ad74a56db8b6"",
        /* IV */  ""95fc6654e6dc3a8adf5e7a69"",
        /* CT */  ""095635c7e0eac0fc1059e67e1a936b6f72671121f96699fed520e5f8aff777f0"",
        /* AAD */ ""de4269feea1a439d6e8990fd6f9f9d5bc67935294425255ea89b6f6772d680fd656b06581a5d8bc5c017ab532b4a9b83a55fde58cdfb3d2a8fef3aa426bc59d3e32f09d3cc20b1ceb9a9e349d1068a0aa3d39617fae0582ccef0"",
        /* Tag */ ""b2235f6d4bdd7b9c0901711048859d47"",
        /* PT */  ""7680b48b5d28f38cdeab2d5851769394a3e141b990ec4bdf79a33e5315ac0338"");
}

bool TestAes128Gcm_TC17(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""93ae114052b7985d409a39a40df8c7ee"",
        /* IV */  ""8ad733a4a9b8330690238c42"",
        /* CT */  ""bbb5b672a479afca2b11adb0a4c762b698dd565908fee1d101f6a01d63332c91b85d7f03ac48a477897d512b4572f9042cb7ea"",
        /* AAD */ """",
        /* Tag */ ""4d78bdcb1366fcba02fdccee57e1ff44"",
        /* PT */  ""3f3bb0644eac878b97d990d257f5b36e1793490dbc13fea4efe9822cebba7444cce4dee5a7f5dfdf285f96785792812200c279"");
}

bool TestAes128Gcm_TC18(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""bc22f3f05cc40db9311e4192966fee92"",
        /* IV */  ""134988e662343c06d3ab83db"",
        /* CT */  ""4c0168ab95d3a10ef25e5924108389365c67d97778995892d9fd46897384af61fc559212b3267e90fe4df7bfd1fbed46f4b9ee"",
        /* AAD */ ""10087e6ed81049b509c31d12fee88c64"",
        /* Tag */ ""771357958a316f166bd0dacc98ea801a"",
        /* PT */  ""337c1bc992386cf0f957617fe4d5ec1218ae1cc40369305518eb177e9b15c1646b142ff71237efaa58790080cd82e8848b295c"");
}

bool TestAes128Gcm_TC19(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""af57f42c60c0fc5a09adb81ab86ca1c3"",
        /* IV */  ""a2dc01871f37025dc0fc9a79"",
        /* CT */  ""b9a535864f48ea7b6b1367914978f9bfa087d854bb0e269bed8d279d2eea1210e48947338b22f9bad09093276a331e9c79c7f4"",
        /* AAD */ ""41dc38988945fcb44faf2ef72d0061289ef8efd8"",
        /* Tag */ ""4f71e72bde0018f555c5adcce062e005"",
        /* PT */  ""3803a0727eeb0ade441e0ec107161ded2d425ec0d102f21f51bf2cf9947c7ec4aa72795b2f69b041596e8817d0a3c16f8fadeb"");
}

bool TestAes128Gcm_TC20(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""f0305c7b513960533519473976f02beb"",
        /* IV */  ""1a7f6ea0e6c9aa5cf8b78b09"",
        /* CT */  ""30043bcbe2177ab25e4b00a92ee1cd80e9daaea0bc0a827fc5fcb84e7b07be6395582a5a14e768dde80a20dae0a8b1d8d1d29b"",
        /* AAD */ ""7e2071cc1c70719143981de543cd28dbceb92de0d6021bda4417e7b6417938b126632ecff6e00766e5d0aad3d6f06811"",
        /* Tag */ ""796c41624f6c3cab762380d21ab6130b"",
        /* PT */  ""e5fc990c0739e05bd4655871c7401128117737a11d520372239ab723f7fde78dc4212ac565ee5ee100a014dbb71ea13cdb08eb"");
}

bool TestAes128Gcm_TC21(void) {
    return TestAes128Gcm_TC(
        /* Key */ ""da2bb7d581493d692380c77105590201"",
        /* IV */  ""44aa3e7856ca279d2eb020c6"",
        /* CT */  ""9290d430c9e89c37f0446dbd620c9a6b34b1274aeb6f911f75867efcf95b6feda69f1af4ee16c761b3c9aeac3da03aa9889c88"",
        /* AAD */ ""4cd171b23bddb3a53cdf959d5c1710b481eb3785a90eb20a2345ee00d0bb7868c367ab12e6f4dd1dee72af4eee1d197777d1d6499cc541f34edbf45cda6ef90b3c024f9272d72ec1909fb8fba7db88a4d6f7d3d925980f9f9f72"",
        /* Tag */ ""9e3ac938d3eb0cadd6f5c9e35d22ba38"",
        /* PT */  ""9bbf4c1a2742f6ac80cb4e8a052e4a8f4f07c43602361355b717381edf9fabd4cb7e3ad65dbd1378b196ac270588dd0621f642"");
}
// clang-format on

// The following tests are taken from the draft AES-GCM RFC (version 6), appendix C.1.  They are
// intentionally formatted to be as close to the RFC's representation as possible.
bool TestAes128GcmSiv_TC(const char* xpt, const char* xaad, const char* xkey, const char* xnonce,
                         const char* xresult) {
    BEGIN_TEST;
    Secret key;
    Bytes ptext, aad, iv, ctext, tag, result;
    uint64_t nonce;
    ASSERT_OK(HexToBytes(xpt, &ptext));
    ASSERT_OK(HexToBytes(xaad, &aad));
    ASSERT_OK(HexToSecret(xkey, &key));
    ASSERT_OK(HexToBytes(xnonce, &iv));
    ASSERT_OK(HexToBytes(xresult, &result));

    AEAD sealer;
    EXPECT_OK(sealer.InitSeal(AEAD::kAES128_GCM_SIV, key, iv));
    EXPECT_OK(sealer.Seal(ptext, aad, &nonce, &ctext));
    EXPECT_TRUE(ctext == result);

    ASSERT_OK(result.Resize(0));
    AEAD opener;
    EXPECT_OK(opener.InitOpen(AEAD::kAES128_GCM_SIV, key, iv));
    EXPECT_OK(opener.Open(nonce, ctext, aad, &result));
    EXPECT_TRUE(ptext == result);
    END_TEST;
}

// clang-format off
bool TestAes128GcmSiv_TC01(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (0 bytes) */  """",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (16 bytes) */    ""dc20e2d83f25705bb49e439eca56de25"");
}

bool TestAes128GcmSiv_TC02(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (8 bytes) */  ""0100000000000000"",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (24 bytes) */    ""b5d839330ac7b786578782fff6013b81""
                                   ""5b287c22493a364c"");
}

bool TestAes128GcmSiv_TC03(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (12 bytes) */ ""010000000000000000000000"",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (28 bytes) */    ""7323ea61d05932260047d942a4978db3""
                                   ""57391a0bc4fdec8b0d106639"");
}

bool TestAes128GcmSiv_TC04(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (16 bytes) */ ""01000000000000000000000000000000"",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (32 bytes) */    ""743f7c8077ab25f8624e2e948579cf77""
                                   ""303aaf90f6fe21199c6068577437a0c4"");
}

bool TestAes128GcmSiv_TC05(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (32 bytes) */ ""01000000000000000000000000000000""
                                   ""02000000000000000000000000000000"",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (48 bytes) */    ""84e07e62ba83a6585417245d7ec413a9""
                                   ""fe427d6315c09b57ce45f2e3936a9445""
                                   ""1a8e45dcd4578c667cd86847bf6155ff"");
}

bool TestAes128GcmSiv_TC06(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (48 bytes) */ ""01000000000000000000000000000000""
                                   ""02000000000000000000000000000000""
                                   ""03000000000000000000000000000000"",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (64 bytes) */    ""3fd24ce1f5a67b75bf2351f181a475c7""
                                   ""b800a5b4d3dcf70106b1eea82fa1d64d""
                                   ""f42bf7226122fa92e17a40eeaac1201b""
                                   ""5e6e311dbf395d35b0fe39c2714388f8"");
}

bool TestAes128GcmSiv_TC07(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (64 bytes) */ ""01000000000000000000000000000000""
                                   ""02000000000000000000000000000000""
                                   ""03000000000000000000000000000000""
                                   ""04000000000000000000000000000000"",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (80 bytes) */    ""2433668f1058190f6d43e360f4f35cd8""
                                   ""e475127cfca7028ea8ab5c20f7ab2af0""
                                   ""2516a2bdcbc08d521be37ff28c152bba""
                                   ""36697f25b4cd169c6590d1dd39566d3f""
                                   ""8a263dd317aa88d56bdf3936dba75bb8"");
}

bool TestAes128GcmSiv_TC08(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (8 bytes) */  ""0200000000000000"",
        /* AAD (1 bytes) */        ""01"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (24 bytes) */    ""1e6daba35669f4273b0a1a2560969cdf""
                                   ""790d99759abd1508"");
}

bool TestAes128GcmSiv_TC09(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (12 bytes) */ ""020000000000000000000000"",
        /* AAD (1 bytes) */        ""01"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (28 bytes) */    ""296c7889fd99f41917f4462008299c51""
                                   ""02745aaa3a0c469fad9e075a"");
}

bool TestAes128GcmSiv_TC10(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (16 bytes) */ ""02000000000000000000000000000000"",
        /* AAD (1 bytes) */        ""01"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (32 bytes) */    ""e2b0c5da79a901c1745f700525cb335b""
                                   ""8f8936ec039e4e4bb97ebd8c4457441f"");
}

bool TestAes128GcmSiv_TC11(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (32 bytes) */ ""02000000000000000000000000000000""
                                   ""03000000000000000000000000000000"",
        /* AAD (1 bytes) */        ""01"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (48 bytes) */    ""620048ef3c1e73e57e02bb8562c416a3""
                                   ""19e73e4caac8e96a1ecb2933145a1d71""
                                   ""e6af6a7f87287da059a71684ed3498e1"");
}

bool TestAes128GcmSiv_TC12(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (48 bytes) */ ""02000000000000000000000000000000""
                                   ""03000000000000000000000000000000""
                                   ""04000000000000000000000000000000"",
        /* AAD (1 bytes) */        ""01"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (64 bytes) */    ""50c8303ea93925d64090d07bd109dfd9""
                                   ""515a5a33431019c17d93465999a8b005""
                                   ""3201d723120a8562b838cdff25bf9d1e""
                                   ""6a8cc3865f76897c2e4b245cf31c51f2"");
}

bool TestAes128GcmSiv_TC13(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (64 bytes) */ ""02000000000000000000000000000000""
                                   ""03000000000000000000000000000000""
                                   ""04000000000000000000000000000000""
                                   ""05000000000000000000000000000000"",
        /* AAD (1 bytes) */        ""01"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (80 bytes) */    ""2f5c64059db55ee0fb847ed513003746""
                                   ""aca4e61c711b5de2e7a77ffd02da42fe""
                                   ""ec601910d3467bb8b36ebbaebce5fba3""
                                   ""0d36c95f48a3e7980f0e7ac299332a80""
                                   ""cdc46ae475563de037001ef84ae21744"");
}

bool TestAes128GcmSiv_TC14(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (4 bytes) */  ""02000000"",
        /* AAD (12 bytes) */       ""010000000000000000000000"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (20 bytes) */    ""a8fe3e8707eb1f84fb28f8cb73de8e99""
                                   ""e2f48a14"");
}

bool TestAes128GcmSiv_TC15(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (20 bytes) */ ""03000000000000000000000000000000""
                                   ""04000000"",
        /* AAD (18 bytes) */       ""01000000000000000000000000000000""
                                   ""0200"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (36 bytes) */    ""6bb0fecf5ded9b77f902c7d5da236a43""
                                   ""91dd029724afc9805e976f451e6d87f6""
                                   ""fe106514"");
}

bool TestAes128GcmSiv_TC16(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (18 bytes) */ ""03000000000000000000000000000000""
                                   ""0400"",
        /* AAD (20 bytes) */       ""01000000000000000000000000000000""
                                   ""02000000"",
        /* Key */                  ""01000000000000000000000000000000"",
        /* Nonce */                ""030000000000000000000000"",
        /* Result (34 bytes) */    ""44d0aaf6fb2f1f34add5e8064e83e12a""
                                   ""2adabff9b2ef00fb47920cc72a0c0f13""
                                   ""b9fd"");
}

bool TestAes128GcmSiv_TC17(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (0 bytes) */  """",
        /* AAD (0 bytes) */        """",
        /* Key */                  ""e66021d5eb8e4f4066d4adb9c33560e4"",
        /* Nonce */                ""f46e44bb3da0015c94f70887"",
        /* Result (16 bytes) */    ""a4194b79071b01a87d65f706e3949578"");
}

bool TestAes128GcmSiv_TC18(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (3 bytes) */  ""7a806c"",
        /* AAD (5 bytes) */        ""46bb91c3c5"",
        /* Key */                  ""36864200e0eaf5284d884a0e77d31646"",
        /* Nonce */                ""bae8e37fc83441b16034566b"",
        /* Result (19 bytes) */    ""af60eb711bd85bc1e4d3e0a462e074ee""
                                   ""a428a8"");
}

bool TestAes128GcmSiv_TC19(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (6 bytes) */  ""bdc66f146545"",
        /* AAD (10 bytes) */       ""fc880c94a95198874296"",
        /* Key */                  ""aedb64a6c590bc84d1a5e269e4b47801"",
        /* Nonce */                ""afc0577e34699b9e671fdd4f"",
        /* Result (22 bytes) */    ""bb93a3e34d3cd6a9c45545cfc11f03ad""
                                   ""743dba20f966"");
}

bool TestAes128GcmSiv_TC20(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (9 bytes) */  ""1177441f195495860f"",
        /* AAD (15 bytes) */       ""046787f3ea22c127aaf195d1894728"",
        /* Key */                  ""d5cc1fd161320b6920ce07787f86743b"",
        /* Nonce */                ""275d1ab32f6d1f0434d8848c"",
        /* Result (25 bytes) */    ""4f37281f7ad12949d01d02fd0cd174c8""
                                   ""4fc5dae2f60f52fd2b"");
}

bool TestAes128GcmSiv_TC21(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (12 bytes) */ ""9f572c614b4745914474e7c7"",
        /* AAD (20 bytes) */       ""c9882e5386fd9f92ec489c8fde2be2cf""
                                   ""97e74e93"",
        /* Key */                  ""b3fed1473c528b8426a582995929a149"",
        /* Nonce */                ""9e9ad8780c8d63d0ab4149c0"",
        /* Result (28 bytes) */    ""f54673c5ddf710c745641c8bc1dc2f87""
                                   ""1fb7561da1286e655e24b7b0"");
}

bool TestAes128GcmSiv_TC22(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (15 bytes) */ ""0d8c8451178082355c9e940fea2f58"",
        /* AAD (25 bytes) */       ""2950a70d5a1db2316fd568378da107b5""
                                   ""2b0da55210cc1c1b0a"",
        /* Key */                  ""2d4ed87da44102952ef94b02b805249b"",
        /* Nonce */                ""ac80e6f61455bfac8308a2d4"",
        /* Result (31 bytes) */    ""c9ff545e07b88a015f05b274540aa183""
                                   ""b3449b9f39552de99dc214a1190b0b"");
}

bool TestAes128GcmSiv_TC23(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (18 bytes) */ ""6b3db4da3d57aa94842b9803a96e07fb""
                                   ""6de7"",
        /* AAD (30 bytes) */       ""1860f762ebfbd08284e421702de0de18""
                                   ""baa9c9596291b08466f37de21c7f"",
        /* Key */                  ""bde3b2f204d1e9f8b06bc47f9745b3d1"",
        /* Nonce */                ""ae06556fb6aa7890bebc18fe"",
        /* Result (34 bytes) */    ""6298b296e24e8cc35dce0bed484b7f30""
                                   ""d5803e377094f04709f64d7b985310a4""
                                   ""db84"");
}

bool TestAes128GcmSiv_TC24(void) {
    return TestAes128GcmSiv_TC(
        /* Plaintext (21 bytes) */ ""e42a3c02c25b64869e146d7b233987bd""
                                   ""dfc240871d"",
        /* AAD (35 bytes) */       ""7576f7028ec6eb5ea7e298342a94d4b2""
                                   ""02b370ef9768ec6561c4fe6b7e7296fa""
                                   ""859c21"",
        /* Key */                  ""f901cfe8a69615a93fdf7a98cad48179"",
        /* Nonce */                ""6245709fb18853f68d833640"",
        /* Result (37 bytes) */    ""391cc328d484a4f46406181bcd62efd9""
                                   ""b3ee197d052d15506c84a9edd65e13e9""
                                   ""d24a2a6e70"");
}
// clang-format off

BEGIN_TEST_CASE(AeadTest)
RUN_TEST(TestGetLengths_Uninitialized)
RUN_EACH(TestGetLengths)
RUN_TEST(TestInitSeal_Uninitialized)
RUN_EACH(TestInitSeal)
RUN_TEST(TestInitOpen_Uninitialized)
RUN_EACH(TestInitOpen)
RUN_EACH(TestSealData)
RUN_EACH(TestOpenData)
RUN_TEST(TestAes128Gcm_TC01)
RUN_TEST(TestAes128Gcm_TC02)
RUN_TEST(TestAes128Gcm_TC03)
RUN_TEST(TestAes128Gcm_TC04)
RUN_TEST(TestAes128Gcm_TC05)
RUN_TEST(TestAes128Gcm_TC06)
RUN_TEST(TestAes128Gcm_TC07)
RUN_TEST(TestAes128Gcm_TC08)
RUN_TEST(TestAes128Gcm_TC09)
RUN_TEST(TestAes128Gcm_TC10)
RUN_TEST(TestAes128Gcm_TC11)
RUN_TEST(TestAes128Gcm_TC12)
RUN_TEST(TestAes128Gcm_TC13)
RUN_TEST(TestAes128Gcm_TC14)
RUN_TEST(TestAes128Gcm_TC15)
RUN_TEST(TestAes128Gcm_TC16)
RUN_TEST(TestAes128Gcm_TC17)
RUN_TEST(TestAes128Gcm_TC18)
RUN_TEST(TestAes128Gcm_TC19)
RUN_TEST(TestAes128Gcm_TC20)
RUN_TEST(TestAes128Gcm_TC21)
RUN_TEST(TestAes128GcmSiv_TC01)
RUN_TEST(TestAes128GcmSiv_TC02)
RUN_TEST(TestAes128GcmSiv_TC03)
RUN_TEST(TestAes128GcmSiv_TC04)
RUN_TEST(TestAes128GcmSiv_TC05)
RUN_TEST(TestAes128GcmSiv_TC06)
RUN_TEST(TestAes128GcmSiv_TC07)
RUN_TEST(TestAes128GcmSiv_TC08)
RUN_TEST(TestAes128GcmSiv_TC09)
RUN_TEST(TestAes128GcmSiv_TC10)
RUN_TEST(TestAes128GcmSiv_TC11)
RUN_TEST(TestAes128GcmSiv_TC12)
RUN_TEST(TestAes128GcmSiv_TC13)
RUN_TEST(TestAes128GcmSiv_TC14)
RUN_TEST(TestAes128GcmSiv_TC15)
RUN_TEST(TestAes128GcmSiv_TC16)
RUN_TEST(TestAes128GcmSiv_TC17)
RUN_TEST(TestAes128GcmSiv_TC18)
RUN_TEST(TestAes128GcmSiv_TC19)
RUN_TEST(TestAes128GcmSiv_TC20)
RUN_TEST(TestAes128GcmSiv_TC21)
RUN_TEST(TestAes128GcmSiv_TC22)
RUN_TEST(TestAes128GcmSiv_TC23)
RUN_TEST(TestAes128GcmSiv_TC24)
END_TEST_CASE(AeadTest)

} // namespace
} // namespace testing
} // namespace crypto
",16147,True,3873.6636859151226,median
"
= Elytron

Elytron can generate the audit log to the same directory where the {Thorntail} application is executed. Include the following section in the `project-defaults.yml` file in your application:

[source,text]
----
thorntail:
  elytron:
    file-audit-logs:
      local-audit:
        path: audit.log
----

In some environments, for example cloud, you might have to relocate the audit file to a globally writable directory, for example:

----
thorntail:
  elytron:
    file-audit-logs:
      local-audit:
        path: /tmp/audit.log
----



.Maven Coordinates
[source,xml]
----
<dependency>
  <groupId>io.thorntail</groupId>
  <artifactId>elytron</artifactId>
</dependency>
----

.Configuration

thorntail.elytron.add-prefix-role-mappers._KEY_.prefix:: 
The prefix to add to each role.

thorntail.elytron.add-suffix-role-mappers._KEY_.suffix:: 
The suffix to add to each role.

thorntail.elytron.aggregate-http-server-mechanism-factories._KEY_.available-mechanisms:: 
The HTTP mechanisms available from this factory instance.

thorntail.elytron.aggregate-http-server-mechanism-factories._KEY_.http-server-mechanism-factories:: 
The referenced http server factories to aggregate.

thorntail.elytron.aggregate-principal-decoders._KEY_.principal-decoders:: 
The referenced principal decoders to aggregate.

thorntail.elytron.aggregate-principal-transformers._KEY_.principal-transformers:: 
The referenced principal transformers to aggregate.

thorntail.elytron.aggregate-providers._KEY_.providers:: 
The referenced Provider[] resources to aggregate.

thorntail.elytron.aggregate-realms._KEY_.authentication-realm:: 
Reference to the security realm to use for authentication steps (obtaining or validating credentials).

thorntail.elytron.aggregate-realms._KEY_.authorization-realm:: 
Reference to the security realm to use for loading the identity for authorization steps (loading of the identity).

thorntail.elytron.aggregate-role-mappers._KEY_.role-mappers:: 
The referenced role mappers to aggregate.

thorntail.elytron.aggregate-sasl-server-factories._KEY_.available-mechanisms:: 
The SASL mechanisms available from this factory after all filtering has been applied.

thorntail.elytron.aggregate-sasl-server-factories._KEY_.sasl-server-factories:: 
The referenced sasl server factories to aggregate.

thorntail.elytron.aggregate-security-event-listeners._KEY_.security-event-listeners:: 
The referenced security event listener resources to aggregate.

thorntail.elytron.authentication-configurations._KEY_.anonymous:: 
Enables anonymous authentication.

thorntail.elytron.authentication-configurations._KEY_.attribute-extends:: 
A previously defined authentication configuration to extend.

thorntail.elytron.authentication-configurations._KEY_.authentication-name:: 
The authentication name to use.

thorntail.elytron.authentication-configurations._KEY_.authorization-name:: 
The authorization name to use.

thorntail.elytron.authentication-configurations._KEY_.credential-reference:: 
The reference to credential stored in CredentialStore under defined alias or clear text password.

thorntail.elytron.authentication-configurations._KEY_.forwarding-mode:: 
The type of security identity forwarding to use. A mode of 'authentication' forwarding forwards the principal and credential. A mode of 'authorization' forwards the authorization id, allowing for a different authentication identity.

thorntail.elytron.authentication-configurations._KEY_.host:: 
The host to use.

thorntail.elytron.authentication-configurations._KEY_.kerberos-security-factory:: 
Reference to a kerberos security factory used to obtain a GSS kerberos credential

thorntail.elytron.authentication-configurations._KEY_.mechanism-properties:: 
Configuration properties for the SASL authentication mechanism.

thorntail.elytron.authentication-configurations._KEY_.port:: 
The port to use.

thorntail.elytron.authentication-configurations._KEY_.protocol:: 
The protocol to use.

thorntail.elytron.authentication-configurations._KEY_.realm:: 
The realm to use.

thorntail.elytron.authentication-configurations._KEY_.sasl-mechanism-selector:: 
The SASL mechanism selector string.

thorntail.elytron.authentication-configurations._KEY_.security-domain:: 
Reference to a security domain to obtain a forwarded identity.

thorntail.elytron.authentication-contexts._KEY_.attribute-extends:: 
A previously defined authentication context to extend.

thorntail.elytron.authentication-contexts._KEY_.match-rules:: 
The match-rules for this authentication context.

thorntail.elytron.caching-realms._KEY_.maximum-age:: 
The time in milliseconds that an item can stay in the cache.

thorntail.elytron.caching-realms._KEY_.maximum-entries:: 
The maximum number of entries to keep in the cache.

thorntail.elytron.caching-realms._KEY_.realm:: 
A reference to a cacheable security realm.

thorntail.elytron.certificate-authority-accounts._KEY_.alias:: 
The alias of certificate authority account key in the keystore. If the alias does not already exist in the keystore, a certificate authority account key will be automatically generated and stored as a PrivateKeyEntry under the alias.

thorntail.elytron.certificate-authority-accounts._KEY_.certificate-authority:: 
The name of the certificate authority to use. Allowed values: ""LetsEncrypt""

thorntail.elytron.certificate-authority-accounts._KEY_.contact-urls:: 
A list of URLs that the certificate authority can contact about any issues related to this account.

thorntail.elytron.certificate-authority-accounts._KEY_.credential-reference:: 
Credential to be used when accessing the certificate authority account key.

thorntail.elytron.certificate-authority-accounts._KEY_.key-store:: 
The keystore that contains the certificate authority account key.

thorntail.elytron.chained-principal-transformers._KEY_.principal-transformers:: 
The referenced principal transformers to chain.

thorntail.elytron.client-ssl-contexts._KEY_.active-session-count:: 
The count of current active sessions.

thorntail.elytron.client-ssl-contexts._KEY_.cipher-suite-filter:: 
The filter to apply to specify the enabled cipher suites.

thorntail.elytron.client-ssl-contexts._KEY_.key-manager:: 
Reference to the key manager to use within the SSLContext.

thorntail.elytron.client-ssl-contexts._KEY_.protocols:: 
The enabled protocols.

thorntail.elytron.client-ssl-contexts._KEY_.provider-name:: 
The name of the provider to use. If not specified, all providers from providers will be passed to the SSLContext.

thorntail.elytron.client-ssl-contexts._KEY_.providers:: 
The name of the providers to obtain the Provider[] to use to load the SSLContext.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.application-buffer-size:: 
The application buffer size as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.cipher-suite:: 
The selected cipher suite as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.creation-time:: 
The creation time as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.last-accessed-time:: 
The last accessed time as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.local-certificates:: 
The local certificates from the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.local-principal:: 
The local principal as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.packet-buffer-size:: 
The packet buffer size as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-certificates:: 
The peer certificates from the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-host:: 
The peer host as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-port:: 
The peer port as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-principal:: 
The peer principal as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.protocol:: 
The protocol as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.ssl-sessions._KEY_.valid:: 
The validity of the session as reported by the SSLSession.

thorntail.elytron.client-ssl-contexts._KEY_.trust-manager:: 
Reference to the trust manager to use within the SSLContext.

thorntail.elytron.concatenating-principal-decoders._KEY_.joiner:: 
The string to use to join the results of the referenced principal decoders.

thorntail.elytron.concatenating-principal-decoders._KEY_.principal-decoders:: 
The referenced principal decoders to concatenate.

thorntail.elytron.configurable-http-server-mechanism-factories._KEY_.available-mechanisms:: 
The HTTP mechanisms available from this factory instance.

thorntail.elytron.configurable-http-server-mechanism-factories._KEY_.filters:: 
Filtering to be applied to enable / disable mechanisms based on the name.

thorntail.elytron.configurable-http-server-mechanism-factories._KEY_.http-server-mechanism-factory:: 
The http server factory to be wrapped.

thorntail.elytron.configurable-http-server-mechanism-factories._KEY_.properties:: 
Custom properties to be passed in to the http server factory calls.

thorntail.elytron.configurable-sasl-server-factories._KEY_.available-mechanisms:: 
The SASL mechanisms available from this factory after all filtering has been applied.

thorntail.elytron.configurable-sasl-server-factories._KEY_.filters:: 
List of filters to be evaluated sequentially combining the results using 'or'.

thorntail.elytron.configurable-sasl-server-factories._KEY_.properties:: 
Custom properties to be passed in to the sasl server factory calls.

thorntail.elytron.configurable-sasl-server-factories._KEY_.protocol:: 
The protocol that should be passed into factory when creating the mechanism.

thorntail.elytron.configurable-sasl-server-factories._KEY_.sasl-server-factory:: 
The sasl server factory to be wrapped.

thorntail.elytron.configurable-sasl-server-factories._KEY_.server-name:: 
The server name that should be passed into factory when creating the mechanism.

thorntail.elytron.constant-permission-mappers._KEY_.permission-sets:: 
The permission sets to assign.

thorntail.elytron.constant-principal-decoders._KEY_.constant:: 
The constant value the principal decoder will always return.

thorntail.elytron.constant-principal-transformers._KEY_.constant:: 
The constant value this PrincipalTransformer will always return.

thorntail.elytron.constant-realm-mappers._KEY_.realm-name:: 
The name of the constant realm to return.

thorntail.elytron.constant-role-mappers._KEY_.roles:: 
The constant roles to be returned by this role mapper.

thorntail.elytron.credential-stores._KEY_.create:: 
Specifies whether credential store should create storage when it doesn't exist.

thorntail.elytron.credential-stores._KEY_.credential-reference:: 
Credential reference to be used to create protection parameter.

thorntail.elytron.credential-stores._KEY_.implementation-properties:: 
Map of credentials store implementation specific properties.

thorntail.elytron.credential-stores._KEY_.location:: 
File name of credential store storage.

thorntail.elytron.credential-stores._KEY_.modifiable:: 
Specifies whether credential store is modifiable.

thorntail.elytron.credential-stores._KEY_.other-providers:: 
The name of the providers defined within the subsystem to obtain the Providers to search for the one that can create the required JCA objects within credential store. This is valid only for key-store based CredentialStore. If this is not specified then the global list of Providers is used instead.

thorntail.elytron.credential-stores._KEY_.provider-name:: 
The name of the provider to use to instantiate the CredentialStoreSpi. If the provider is not specified then the first provider found that can create an instance of the specified 'type' will be used.

thorntail.elytron.credential-stores._KEY_.providers:: 
The name of the providers defined within the subsystem to obtain the Providers to search for the one that can create the required CredentialStore type. If this is not specified then the global list of Providers is used instead.

thorntail.elytron.credential-stores._KEY_.relative-to:: 
A reference to a previously defined path that the file name is relative to.

thorntail.elytron.credential-stores._KEY_.state:: 
The state of the underlying service that represents this credential store at runtime.

thorntail.elytron.credential-stores._KEY_.type:: 
The credential store type, e.g. KeyStoreCredentialStore.

thorntail.elytron.custom-credential-security-factories._KEY_.class-name:: 
The class name of the implementation of the custom security factory.

thorntail.elytron.custom-credential-security-factories._KEY_.configuration:: 
The optional key/value configuration for the custom security factory.

thorntail.elytron.custom-credential-security-factories._KEY_.module:: 
The module to use to load the custom security factory.

thorntail.elytron.custom-modifiable-realms._KEY_.class-name:: 
The class name of the implementation of the custom realm.

thorntail.elytron.custom-modifiable-realms._KEY_.configuration:: 
The optional key/value configuration for the custom realm.

thorntail.elytron.custom-modifiable-realms._KEY_.module:: 
The module to use to load the custom realm.

thorntail.elytron.custom-permission-mappers._KEY_.class-name:: 
Fully qualified class name of the permission mapper

thorntail.elytron.custom-permission-mappers._KEY_.configuration:: 
The optional kay/value configuration for the permission mapper

thorntail.elytron.custom-permission-mappers._KEY_.module:: 
Name of the module to use to load the permission mapper

thorntail.elytron.custom-principal-decoders._KEY_.class-name:: 
Fully qualified class name of the principal decoder

thorntail.elytron.custom-principal-decoders._KEY_.configuration:: 
The optional kay/value configuration for the principal decoder

thorntail.elytron.custom-principal-decoders._KEY_.module:: 
Name of the module to use to load the principal decoder

thorntail.elytron.custom-principal-transformers._KEY_.class-name:: 
The class name of the implementation of the custom principal transformer.

thorntail.elytron.custom-principal-transformers._KEY_.configuration:: 
The optional key/value configuration for the custom principal transformer.

thorntail.elytron.custom-principal-transformers._KEY_.module:: 
The module to use to load the custom principal transformer.

thorntail.elytron.custom-realm-mappers._KEY_.class-name:: 
Fully qualified class name of the RealmMapper

thorntail.elytron.custom-realm-mappers._KEY_.configuration:: 
The optional kay/value configuration for the RealmMapper

thorntail.elytron.custom-realm-mappers._KEY_.module:: 
Name of the module to use to load the RealmMapper

thorntail.elytron.custom-realms._KEY_.class-name:: 
The class name of the implementation of the custom realm.

thorntail.elytron.custom-realms._KEY_.configuration:: 
The optional key/value configuration for the custom realm.

thorntail.elytron.custom-realms._KEY_.module:: 
The module to use to load the custom realm.

thorntail.elytron.custom-role-decoders._KEY_.class-name:: 
Fully qualified class name of the RoleDecoder

thorntail.elytron.custom-role-decoders._KEY_.configuration:: 
The optional kay/value configuration for the RoleDecoder

thorntail.elytron.custom-role-decoders._KEY_.module:: 
Name of the module to use to load the RoleDecoder

thorntail.elytron.custom-role-mappers._KEY_.class-name:: 
Fully qualified class name of the RoleMapper

thorntail.elytron.custom-role-mappers._KEY_.configuration:: 
The optional key/value configuration for the RoleMapper

thorntail.elytron.custom-role-mappers._KEY_.module:: 
Name of the module to use to load the RoleMapper

thorntail.elytron.custom-security-event-listeners._KEY_.class-name:: 
The class name of the implementation of the custom security event listener.

thorntail.elytron.custom-security-event-listeners._KEY_.configuration:: 
The optional key/value configuration for the custom security event listener.

thorntail.elytron.custom-security-event-listeners._KEY_.module:: 
The module to use to load the custom security event listener.

thorntail.elytron.default-authentication-context:: 
The default authentication context to be associated with all deployments.

thorntail.elytron.dir-contexts._KEY_.authentication-context:: 
The authentication context to obtain login credentials to connect to the LDAP server. Can be omitted if authentication-level is ""none"" (anonymous).

thorntail.elytron.dir-contexts._KEY_.authentication-level:: 
The authentication level (security level/authentication mechanism) to use. Corresponds to SECURITY_AUTHENTICATION (""java.naming.security.authentication"") environment property. Allowed values: ""none"", ""simple"", sasl_mech, where sasl_mech is a space-separated list of SASL mechanism names.

thorntail.elytron.dir-contexts._KEY_.connection-timeout:: 
The timeout for connecting to the LDAP server in milliseconds.

thorntail.elytron.dir-contexts._KEY_.credential-reference:: 
The credential reference to authenticate and connect to the LDAP server. Can be omitted if authentication-level is ""none"" (anonymous).

thorntail.elytron.dir-contexts._KEY_.enable-connection-pooling:: 
Indicates if connection pooling is enabled.

thorntail.elytron.dir-contexts._KEY_.module:: 
Name of module that will be used as class loading base.

thorntail.elytron.dir-contexts._KEY_.principal:: 
The principal to authenticate and connect to the LDAP server. Can be omitted if authentication-level is ""none"" (anonymous).

thorntail.elytron.dir-contexts._KEY_.properties:: 
The additional connection properties for the DirContext.

thorntail.elytron.dir-contexts._KEY_.read-timeout:: 
The read timeout for an LDAP operation in milliseconds.

thorntail.elytron.dir-contexts._KEY_.referral-mode:: 
If referrals should be followed.

thorntail.elytron.dir-contexts._KEY_.ssl-context:: 
The name of ssl-context used to secure connection to the LDAP server.

thorntail.elytron.dir-contexts._KEY_.url:: 
The connection url.

thorntail.elytron.disallowed-providers:: 
A list of providers that are not allowed, and will be removed from the providers list.

thorntail.elytron.file-audit-logs._KEY_.attribute-synchronized:: 
Whether every event should be immediately synchronised to disk.

thorntail.elytron.file-audit-logs._KEY_.format:: 
The format to use to record the audit event.

thorntail.elytron.file-audit-logs._KEY_.path:: 
Path of the file to be written.

thorntail.elytron.file-audit-logs._KEY_.relative-to:: 
The relative path to the audit log.

thorntail.elytron.filesystem-realms._KEY_.encoded:: 
Whether the identity names should be stored encoded (Base32) in file names.

thorntail.elytron.filesystem-realms._KEY_.levels:: 
The number of levels of directory hashing to apply.

thorntail.elytron.filesystem-realms._KEY_.path:: 
The path to the file containing the realm.

thorntail.elytron.filesystem-realms._KEY_.relative-to:: 
The pre-defined path the path is relative to.

thorntail.elytron.filtering-key-stores._KEY_.alias-filter:: 
A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2

thorntail.elytron.filtering-key-stores._KEY_.key-store:: 
Name of filtered KeyStore.

thorntail.elytron.filtering-key-stores._KEY_.state:: 
The state of the underlying service that represents this KeyStore at runtime, if it is anything other than UP runtime operations will not be available.

thorntail.elytron.final-providers:: 
Reference to the Providers that should be registered after all existing Providers.

thorntail.elytron.http-authentication-factories._KEY_.available-mechanisms:: 
The HTTP mechanisms available from this configuration after all filtering has been applied.

thorntail.elytron.http-authentication-factories._KEY_.http-server-mechanism-factory:: 
The HttpServerAuthenticationMechanismFactory to associate with this resource

thorntail.elytron.http-authentication-factories._KEY_.mechanism-configurations:: 
Mechanism specific configuration

thorntail.elytron.http-authentication-factories._KEY_.security-domain:: 
The SecurityDomain to associate with this resource

thorntail.elytron.identity-realms._KEY_.attribute-name:: 
The name of the attribute associated with this identity.

thorntail.elytron.identity-realms._KEY_.attribute-values:: 
The values associated with the identity attributes.

thorntail.elytron.identity-realms._KEY_.identity:: 
The name of the identity available from the security realm.

thorntail.elytron.initial-providers:: 
Reference to the Providers that should be registered ahead of all existing Providers.

thorntail.elytron.jdbc-realms._KEY_.principal-query:: 
The authentication query used to authenticate users based on specific key types.

thorntail.elytron.kerberos-security-factories._KEY_.debug:: 
Should the JAAS step of obtaining the credential have debug logging enabled.

thorntail.elytron.kerberos-security-factories._KEY_.fail-cache:: 
Amount of seconds before new try to obtain server credential should be done if it has failed last time.

thorntail.elytron.kerberos-security-factories._KEY_.mechanism-names:: 
The mechanism names the credential should be usable with. Names will be converted to OIDs and used together with OIDs from mechanism-oids attribute.

thorntail.elytron.kerberos-security-factories._KEY_.mechanism-oids:: 
The mechanism OIDs the credential should be usable with. Will be used together with OIDs derived from names from mechanism-names attribute.

thorntail.elytron.kerberos-security-factories._KEY_.minimum-remaining-lifetime:: 
How much lifetime (in seconds) should a cached credential have remaining before it is recreated.

thorntail.elytron.kerberos-security-factories._KEY_.obtain-kerberos-ticket:: 
Should the KerberosTicket also be obtained and associated with the credential. This is required to be true where credentials are delegated to the server.

thorntail.elytron.kerberos-security-factories._KEY_.options:: 
The Krb5LoginModule additional options.

thorntail.elytron.kerberos-security-factories._KEY_.path:: 
The path of the KeyTab to load to obtain the credential.

thorntail.elytron.kerberos-security-factories._KEY_.principal:: 
The principal represented by the KeyTab

thorntail.elytron.kerberos-security-factories._KEY_.relative-to:: 
The name of another previously named path, or of one of the standard paths provided by the system. If 'relative-to' is provided, the value of the 'path' attribute is treated as relative to the path specified by this attribute.

thorntail.elytron.kerberos-security-factories._KEY_.request-lifetime:: 
How much lifetime (in seconds) should be requested for newly created credentials.

thorntail.elytron.kerberos-security-factories._KEY_.required:: 
Is the keytab file with adequate principal required to exist at the time the service starts?

thorntail.elytron.kerberos-security-factories._KEY_.server:: 
If this for use server side or client side?

thorntail.elytron.kerberos-security-factories._KEY_.wrap-gss-credential:: 
Should generated GSS credentials be wrapped to prevent improper disposal or not?

thorntail.elytron.key-managers._KEY_.algorithm:: 
The name of the algorithm to use to create the underlying KeyManagerFactory.

thorntail.elytron.key-managers._KEY_.alias-filter:: 
A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2

thorntail.elytron.key-managers._KEY_.credential-reference:: 
The credential reference to decrypt KeyStore item. (Not a password of the KeyStore.)

thorntail.elytron.key-managers._KEY_.key-store:: 
Reference to the KeyStore to use to initialise the underlying KeyManagerFactory.

thorntail.elytron.key-managers._KEY_.provider-name:: 
The name of the provider to use to create the underlying KeyManagerFactory.

thorntail.elytron.key-managers._KEY_.providers:: 
Reference to obtain the Provider[] to use when creating the underlying KeyManagerFactory.

thorntail.elytron.key-store-realms._KEY_.key-store:: 
Reference to the KeyStore that should be used to back this security realm.

thorntail.elytron.key-stores._KEY_.alias-filter:: 
A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2

thorntail.elytron.key-stores._KEY_.attribute-synchronized:: 
The time this KeyStore was last loaded or saved. Note: Some providers may continue to apply updates after the KeyStore was loaded within the application server.

thorntail.elytron.key-stores._KEY_.credential-reference:: 
The reference to credential stored in CredentialStore under defined alias or clear text password.

thorntail.elytron.key-stores._KEY_.loaded-provider:: 
Information about the provider that was used for this KeyStore.

thorntail.elytron.key-stores._KEY_.modified:: 
Indicates if the in-memory representation of the KeyStore has been changed since it was last loaded or stored.  Note: For some providers updates may be immediate without further load or store calls.

thorntail.elytron.key-stores._KEY_.path:: 
The path to the KeyStore file.

thorntail.elytron.key-stores._KEY_.provider-name:: 
The name of the provider to use to load the KeyStore, disables searching for the first Provider that can create a KeyStore of the specified type.

thorntail.elytron.key-stores._KEY_.providers:: 
A reference to the providers that should be used to obtain the list of Provider instances to search, if not specified the global list of providers will be used instead.

thorntail.elytron.key-stores._KEY_.relative-to:: 
The base path this store is relative to.

thorntail.elytron.key-stores._KEY_.required:: 
Is the file required to exist at the time the KeyStore service starts?

thorntail.elytron.key-stores._KEY_.size:: 
The number of entries in the KeyStore.

thorntail.elytron.key-stores._KEY_.state:: 
The state of the underlying service that represents this KeyStore at runtime, if it is anything other than UP runtime operations will not be available.

thorntail.elytron.key-stores._KEY_.type:: 
The type of the KeyStore, used when creating the new KeyStore instance.

thorntail.elytron.ldap-key-stores._KEY_.alias-attribute:: 
The name of LDAP attribute, where will be item alias stored.

thorntail.elytron.ldap-key-stores._KEY_.certificate-attribute:: 
The name of LDAP attribute, where will be certificate stored.

thorntail.elytron.ldap-key-stores._KEY_.certificate-chain-attribute:: 
The name of LDAP attribute, where will be certificate chain stored.

thorntail.elytron.ldap-key-stores._KEY_.certificate-chain-encoding:: 
The encoding of the certificate chain.

thorntail.elytron.ldap-key-stores._KEY_.certificate-type:: 
The type of the Certificate.

thorntail.elytron.ldap-key-stores._KEY_.dir-context:: 
The name of DirContext, which will be used to communication with LDAP server.

thorntail.elytron.ldap-key-stores._KEY_.filter-alias:: 
The LDAP filter for obtaining an item of the KeyStore by alias. If this is not specified then the default value will be (alias_attribute={0}). The string '{0}' will be replaced by the searched alias and the 'alias_attribute' value will be the value of the attribute 'alias-attribute'.

thorntail.elytron.ldap-key-stores._KEY_.filter-certificate:: 
The LDAP filter for obtaining an item of the KeyStore by certificate. If this is not specified then the default value will be (certificate_attribute={0}). The string '{0}' will be replaced by searched encoded certificate and the 'certificate_attribute' will be the value of the attribute 'certificate-attribute'.

thorntail.elytron.ldap-key-stores._KEY_.filter-iterate:: 
The LDAP filter for iterating over all items of the KeyStore. If this is not specified then the default value will be (alias_attribute=*). The 'alias_attribute' will be the value of the attribute 'alias-attribute'.

thorntail.elytron.ldap-key-stores._KEY_.key-attribute:: 
The name of LDAP attribute, where will be key stored.

thorntail.elytron.ldap-key-stores._KEY_.key-type:: 
The type of KeyStore, in which will be key serialized to LDAP attribute.

thorntail.elytron.ldap-key-stores._KEY_.new-item-template:: 
Configuration for item creation. Define how will look LDAP entry of newly created keystore item.

thorntail.elytron.ldap-key-stores._KEY_.search-path:: 
The path in LDAP, where will be KeyStore items searched.

thorntail.elytron.ldap-key-stores._KEY_.search-recursive:: 
If the LDAP search should be recursive.

thorntail.elytron.ldap-key-stores._KEY_.search-time-limit:: 
The time limit for obtaining keystore items from LDAP.

thorntail.elytron.ldap-key-stores._KEY_.size:: 
The size of LDAP KeyStore in amount of items/aliases.

thorntail.elytron.ldap-key-stores._KEY_.state:: 
The state of the underlying service that represents this KeyStore at runtime, if it is anything other than UP runtime operations will not be available.

thorntail.elytron.ldap-realms._KEY_.allow-blank-password:: 
Does this realm support blank password direct verification? Blank password attempt will be rejected otherwise.

thorntail.elytron.ldap-realms._KEY_.dir-context:: 
The configuration to connect to a LDAP server.

thorntail.elytron.ldap-realms._KEY_.direct-verification:: 
Does this realm support verification of credentials by directly connecting to LDAP as the account being authenticated?

thorntail.elytron.ldap-realms._KEY_.identity-mapping:: 
The configuration options that define how principals are mapped to their corresponding entries in the underlying LDAP server.

thorntail.elytron.logical-permission-mappers._KEY_.left:: 
Reference to the permission mapper to use to the left of the operation.

thorntail.elytron.logical-permission-mappers._KEY_.logical-operation:: 
The logical operation to use to combine the permission mappers.

thorntail.elytron.logical-permission-mappers._KEY_.right:: 
Reference to the permission mapper to use to the right of the operation.

thorntail.elytron.logical-role-mappers._KEY_.left:: 
Reference to a role mapper to be used on the left side of the operation.

thorntail.elytron.logical-role-mappers._KEY_.logical-operation:: 
The logical operation to be performed on the role mapper mappings.

thorntail.elytron.logical-role-mappers._KEY_.right:: 
Reference to a role mapper to be used on the right side of the operation.

thorntail.elytron.mapped-regex-realm-mappers._KEY_.delegate-realm-mapper:: 
The RealmMapper to delegate to if the pattern does not match. If no delegate is specified then the default realm on the domain will be used instead. If the username does not match the pattern and a delegate realm-mapper is present, the result of delegate-realm-mapper is mapped via the realm-map.

thorntail.elytron.mapped-regex-realm-mappers._KEY_.pattern:: 
The regular expression which must contain at least one capture group to extract the realm from the name. If the regular expression matches more than one capture group, the first capture group is used.

thorntail.elytron.mapped-regex-realm-mappers._KEY_.realm-map:: 
Mapping of realm name extracted using the regular expression to a defined realm name. If the value for the mapping is not in the map or the realm whose name is the result of the mapping does not exist in the given security domain, the default realm is used.

thorntail.elytron.mapped-role-mappers._KEY_.keep-mapped:: 
When set to 'true' the mapped roles will retain all roles, that have defined mappings.

thorntail.elytron.mapped-role-mappers._KEY_.keep-non-mapped:: 
When set to 'true' the mapped roles will retain all roles, that have no defined mappings.

thorntail.elytron.mapped-role-mappers._KEY_.role-map:: 
A string to string list map for mapping roles.

thorntail.elytron.mechanism-provider-filtering-sasl-server-factories._KEY_.available-mechanisms:: 
The SASL mechanisms available from this factory after all filtering has been applied.

thorntail.elytron.mechanism-provider-filtering-sasl-server-factories._KEY_.enabling:: 
When set to 'true' no provider loaded mechanisms are enabled unless matched by one of the filters, setting to 'false' has the inverse effect.

thorntail.elytron.mechanism-provider-filtering-sasl-server-factories._KEY_.filters:: 
The filters to apply when comparing the mechanisms from the providers, a filter matches when all of the specified values match the mechanism / provider pair.

thorntail.elytron.mechanism-provider-filtering-sasl-server-factories._KEY_.sasl-server-factory:: 
Reference to a sasl server factory to be wrapped by this definition.

thorntail.elytron.periodic-rotating-file-audit-logs._KEY_.attribute-synchronized:: 
Whether every event should be immediately synchronised to disk.

thorntail.elytron.periodic-rotating-file-audit-logs._KEY_.format:: 
The format to use to record the audit event.

thorntail.elytron.periodic-rotating-file-audit-logs._KEY_.path:: 
Path of the file to be written.

thorntail.elytron.periodic-rotating-file-audit-logs._KEY_.relative-to:: 
The relative path to the audit log.

thorntail.elytron.periodic-rotating-file-audit-logs._KEY_.suffix:: 
The suffix string in a format which can be understood by java.time.format.DateTimeFormatter. The period of the rotation is automatically calculated based on the suffix.

thorntail.elytron.permission-sets._KEY_.permissions:: 
The permissions in the permission set.

thorntail.elytron.policies._KEY_.custom-policy:: 
A custom policy provider definition.

thorntail.elytron.policies._KEY_.jacc-policy:: 
A policy provider definition that sets up JACC and related services.

thorntail.elytron.properties-realms._KEY_.attribute-synchronized:: 
The time the properties files that back this realm were last loaded.

thorntail.elytron.properties-realms._KEY_.groups-attribute:: 
The name of the attribute in the returned AuthorizationIdentity that should contain the group membership information for the identity.

thorntail.elytron.properties-realms._KEY_.groups-properties:: 
The properties file containing the users and their groups.

thorntail.elytron.properties-realms._KEY_.users-properties:: 
The properties file containing the users and their passwords.

thorntail.elytron.provider-http-server-mechanism-factories._KEY_.available-mechanisms:: 
The HTTP mechanisms available from this factory instance.

thorntail.elytron.provider-http-server-mechanism-factories._KEY_.providers:: 
The providers to use to locate the factories, if not specified the globally registered list of Providers will be used.

thorntail.elytron.provider-loaders._KEY_.argument:: 
An argument to be passed into the constructor as the Provider is instantiated.

thorntail.elytron.provider-loaders._KEY_.class-names:: 
The fully qualified class names of the providers to load, these are loaded after the service-loader discovered providers and duplicates will be skipped.

thorntail.elytron.provider-loaders._KEY_.configuration:: 
The key/value configuration to be passed to the Provider to initialise it.

thorntail.elytron.provider-loaders._KEY_.loaded-providers:: 
The list of providers loaded by this provider loader.

thorntail.elytron.provider-loaders._KEY_.module:: 
The name of the module to load the provider from.

thorntail.elytron.provider-loaders._KEY_.path:: 
The path of the file to use to initialise the providers.

thorntail.elytron.provider-loaders._KEY_.relative-to:: 
The base path of the configuration file.

thorntail.elytron.provider-sasl-server-factories._KEY_.available-mechanisms:: 
The SASL mechanisms available from this factory after all filtering has been applied.

thorntail.elytron.provider-sasl-server-factories._KEY_.providers:: 
The providers to use to locate the factories, if not specified the globally registered list of Providers will be used.

thorntail.elytron.regex-principal-transformers._KEY_.pattern:: 
The regular expression to use to locate the portion of the name to be replaced.

thorntail.elytron.regex-principal-transformers._KEY_.replace-all:: 
Should all occurrences of the pattern matched be replaced or only the first occurrence.

thorntail.elytron.regex-principal-transformers._KEY_.replacement:: 
The value to be used as the replacement.

thorntail.elytron.regex-validating-principal-transformers._KEY_.match:: 
If set to true, the name must match the given pattern to make validation successful. If set to false, the name must not match the given pattern to make validation successful.

thorntail.elytron.regex-validating-principal-transformers._KEY_.pattern:: 
The regular expression to use for the principal transformer.

thorntail.elytron.sasl-authentication-factories._KEY_.available-mechanisms:: 
The SASL mechanisms available from this configuration after all filtering has been applied.

thorntail.elytron.sasl-authentication-factories._KEY_.mechanism-configurations:: 
Mechanism specific configuration

thorntail.elytron.sasl-authentication-factories._KEY_.sasl-server-factory:: 
The SaslServerFactory to associate with this resource

thorntail.elytron.sasl-authentication-factories._KEY_.security-domain:: 
The SecurityDomain to associate with this resource

thorntail.elytron.security-domains._KEY_.default-realm:: 
The default realm contained by this security domain.

thorntail.elytron.security-domains._KEY_.outflow-anonymous:: 
When outflowing to a security domain if outflow is not possible should the anonymous identity be used?  Outflowing anonymous has the effect of clearing any identity already established for that domain.

thorntail.elytron.security-domains._KEY_.outflow-security-domains:: 
The list of security domains that the security identity from this domain should automatically outflow to.

thorntail.elytron.security-domains._KEY_.permission-mapper:: 
A reference to a PermissionMapper to be used by this domain.

thorntail.elytron.security-domains._KEY_.post-realm-principal-transformer:: 
A reference to a principal transformer to be applied after the realm has operated on the supplied identity name.

thorntail.elytron.security-domains._KEY_.pre-realm-principal-transformer:: 
A reference to a principal transformer to be applied before the realm is selected.

thorntail.elytron.security-domains._KEY_.principal-decoder:: 
A reference to a PrincipalDecoder to be used by this domain.

thorntail.elytron.security-domains._KEY_.realm-mapper:: 
Reference to the RealmMapper to be used by this domain.

thorntail.elytron.security-domains._KEY_.realms:: 
The list of realms contained by this security domain.

thorntail.elytron.security-domains._KEY_.role-mapper:: 
Reference to the RoleMapper to be used by this domain.

thorntail.elytron.security-domains._KEY_.security-event-listener:: 
Reference to a listener for security events.

thorntail.elytron.security-domains._KEY_.trusted-security-domains:: 
The list of security domains that are trusted by this security domain.

thorntail.elytron.security-properties:: 
Security properties to be set.

thorntail.elytron.server-ssl-contexts._KEY_.active-session-count:: 
The count of current active sessions.

thorntail.elytron.server-ssl-contexts._KEY_.authentication-optional:: 
Rejecting of the client certificate by the security domain will not prevent the connection. Allows a fall through to use other authentication mechanisms (like form login) when the client certificate is rejected by security domain. Has an effect only when the security domain is set.

thorntail.elytron.server-ssl-contexts._KEY_.cipher-suite-filter:: 
The filter to apply to specify the enabled cipher suites.

thorntail.elytron.server-ssl-contexts._KEY_.final-principal-transformer:: 
A final principal transformer to apply for this mechanism realm.

thorntail.elytron.server-ssl-contexts._KEY_.key-manager:: 
Reference to the key manager to use within the SSLContext.

thorntail.elytron.server-ssl-contexts._KEY_.maximum-session-cache-size:: 
The maximum number of SSL sessions in the cache. The default value -1 means use the JVM default value. Value zero means there is no limit.

thorntail.elytron.server-ssl-contexts._KEY_.need-client-auth:: 
To require a client certificate on SSL handshake. Connection without trusted client certificate (see trust-manager) will be rejected.

thorntail.elytron.server-ssl-contexts._KEY_.post-realm-principal-transformer:: 
A principal transformer to apply after the realm is selected.

thorntail.elytron.server-ssl-contexts._KEY_.pre-realm-principal-transformer:: 
A principal transformer to apply before the realm is selected.

thorntail.elytron.server-ssl-contexts._KEY_.protocols:: 
The enabled protocols.

thorntail.elytron.server-ssl-contexts._KEY_.provider-name:: 
The name of the provider to use. If not specified, all providers from providers will be passed to the SSLContext.

thorntail.elytron.server-ssl-contexts._KEY_.providers:: 
The name of the providers to obtain the Provider[] to use to load the SSLContext.

thorntail.elytron.server-ssl-contexts._KEY_.realm-mapper:: 
The realm mapper to be used for SSL authentication.

thorntail.elytron.server-ssl-contexts._KEY_.security-domain:: 
The security domain to use for authentication during SSL session establishment.

thorntail.elytron.server-ssl-contexts._KEY_.session-timeout:: 
The timeout for SSL sessions, in seconds. The default value -1 means use the JVM default value. Value zero means there is no limit.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.application-buffer-size:: 
The application buffer size as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.cipher-suite:: 
The selected cipher suite as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.creation-time:: 
The creation time as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.last-accessed-time:: 
The last accessed time as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.local-certificates:: 
The local certificates from the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.local-principal:: 
The local principal as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.packet-buffer-size:: 
The packet buffer size as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-certificates:: 
The peer certificates from the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-host:: 
The peer host as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-port:: 
The peer port as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.peer-principal:: 
The peer principal as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.protocol:: 
The protocol as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.ssl-sessions._KEY_.valid:: 
The validity of the session as reported by the SSLSession.

thorntail.elytron.server-ssl-contexts._KEY_.trust-manager:: 
Reference to the trust manager to use within the SSLContext.

thorntail.elytron.server-ssl-contexts._KEY_.use-cipher-suites-order:: 
To honor local cipher suites preference.

thorntail.elytron.server-ssl-contexts._KEY_.want-client-auth:: 
To request (but not to require) a client certificate on SSL handshake. If a security domain is referenced and supports X509 evidence, this will be set to true automatically. Ignored when need-client-auth is set.

thorntail.elytron.server-ssl-contexts._KEY_.wrap:: 
Should the SSLEngine, SSLSocket, and SSLServerSocket instances returned be wrapped to protect against further modification.

thorntail.elytron.service-loader-http-server-mechanism-factories._KEY_.available-mechanisms:: 
The HTTP mechanisms available from this factory instance.

thorntail.elytron.service-loader-http-server-mechanism-factories._KEY_.module:: 
The module to use to obtain the classloader to load the factories, if not specified the classloader to load the resource will be used instead.

thorntail.elytron.service-loader-sasl-server-factories._KEY_.available-mechanisms:: 
The SASL mechanisms available from this factory after all filtering has been applied.

thorntail.elytron.service-loader-sasl-server-factories._KEY_.module:: 
The module to use to obtain the classloader to load the factories, if not specified the classloader to load the resource will be used instead.

thorntail.elytron.simple-permission-mappers._KEY_.mapping-mode:: 
The mapping mode that should be used in the event of multiple matches.

thorntail.elytron.simple-permission-mappers._KEY_.permission-mappings:: 
The defined permission mappings.

thorntail.elytron.simple-regex-realm-mappers._KEY_.delegate-realm-mapper:: 
The RealmMapper to delegate to if there is no match using the pattern.

thorntail.elytron.simple-regex-realm-mappers._KEY_.pattern:: 
The regular expression which must contain at least one capture group to extract the realm from the name. If the regular expression matches more than one capture group, the first capture group is used.

thorntail.elytron.simple-role-decoders._KEY_.attribute:: 
The name of the attribute from the identity to map directly to roles.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.attribute-synchronized:: 
Whether every event should be immediately synchronised to disk.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.format:: 
The format to use to record the audit event.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.max-backup-index:: 
The maximum number of files to backup when rotating.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.path:: 
Path of the file to be written.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.relative-to:: 
The relative path to the audit log.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.rotate-on-boot:: 
Whether the file should be rotated before the a new file is set.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.rotate-size:: 
The log file size the file should rotate at.

thorntail.elytron.size-rotating-file-audit-logs._KEY_.suffix:: 
Format of date used as suffix of log file names in java.time.format.DateTimeFormatter. The suffix does not play a role in determining when the file should be rotated.

thorntail.elytron.syslog-audit-logs._KEY_.format:: 
The format to use to record the audit event.

thorntail.elytron.syslog-audit-logs._KEY_.host-name:: 
The host name to embed withing all events sent to the remote syslog server.

thorntail.elytron.syslog-audit-logs._KEY_.port:: 
The listening port on the syslog server.

thorntail.elytron.syslog-audit-logs._KEY_.server-address:: 
The server address of the syslog server the events should be sent to.

thorntail.elytron.syslog-audit-logs._KEY_.ssl-context:: 
The SSLContext to use to connect to the syslog server when SSL_TCP transport is used.

thorntail.elytron.syslog-audit-logs._KEY_.transport:: 
The transport to use to connect to the syslog server.

thorntail.elytron.token-realms._KEY_.jwt:: 
A token validator to be used in conjunction with a token-based realm that handles security tokens based on the JWT/JWS standard.

thorntail.elytron.token-realms._KEY_.oauth2-introspection:: 
A token validator to be used in conjunction with a token-based realm that handles OAuth2 Access Tokens and validates them using an endpoint compliant with OAuth2 Token Introspection specification(RFC-7662).

thorntail.elytron.token-realms._KEY_.principal-claim:: 
The name of the claim that should be used to obtain the principal's name.

thorntail.elytron.trust-managers._KEY_.algorithm:: 
The name of the algorithm to use to create the underlying TrustManagerFactory.

thorntail.elytron.trust-managers._KEY_.alias-filter:: 
A filter to apply to the aliases returned from the KeyStore, can either be a comma separated list of aliases to return or one of the following formats ALL:-alias1:-alias2, NONE:+alias1:+alias2

thorntail.elytron.trust-managers._KEY_.certificate-revocation-list:: 
Enables certificate revocation list checks to a trust manager.

thorntail.elytron.trust-managers._KEY_.key-store:: 
Reference to the KeyStore to use to initialise the underlying TrustManagerFactory.

thorntail.elytron.trust-managers._KEY_.provider-name:: 
The name of the provider to use to create the underlying TrustManagerFactory.

thorntail.elytron.trust-managers._KEY_.providers:: 
Reference to obtain the Provider[] to use when creating the underlying TrustManagerFactory.

thorntail.elytron.x500-attribute-principal-decoders._KEY_.attribute-name:: 
The name of the X.500 attribute to map (can be defined using OID instead)

thorntail.elytron.x500-attribute-principal-decoders._KEY_.convert:: 
When set to 'true', if the Principal is not already an X500Principal conversion will be attempted

thorntail.elytron.x500-attribute-principal-decoders._KEY_.joiner:: 
The joining string

thorntail.elytron.x500-attribute-principal-decoders._KEY_.maximum-segments:: 
The maximum number of occurrences of the attribute to map

thorntail.elytron.x500-attribute-principal-decoders._KEY_.oid:: 
The OID of the X.500 attribute to map (can be defined using attribute name instead)

thorntail.elytron.x500-attribute-principal-decoders._KEY_.required-attributes:: 
The attributes names of the attributes that must be present in the principal

thorntail.elytron.x500-attribute-principal-decoders._KEY_.required-oids:: 
The OIDs of the attributes that must be present in the principal

thorntail.elytron.x500-attribute-principal-decoders._KEY_.reverse:: 
When set to 'true', the attribute values will be processed and returned in reverse order

thorntail.elytron.x500-attribute-principal-decoders._KEY_.start-segment:: 
The 0-based starting occurrence of the attribute to map


",12114,True,3049.809337564988,median
"
////////////////////////////////////////////////////////////////////////////////
// Header Files ////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
   #include ""formatted_console_io_v18.h""
   #include <fstream>
   using namespace std ;


////////////////////////////////////////////////////////////////////////////////
// Global Constant Definitions /////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// entire screen dimensions
const int UPRLEFTX   = 0;
const int UPRLEFTY   = 0;
const int SCR_W      = 80;
const int SCR_H      = 28;
const int SCR_CENTER = 39;

// instruction screen dimensions/reference points
const int INSTR_UPX = 12;         ////////////////////////////////////////////////
const int INSTR_UPY = 2;
const int INSTR_W   = 53;         ////////////////////////////////////////////////
const int INSTR_H   = 16;

// main menu dimensions/reference points
const int MENU_UPX    = 15;      //////////////////////////////////////////////////
const int MENU_UPY    = 5;       //////////////////////////////////////////////////
const int MENU_W      = 30;      //////////////////////////////////////////////////
const int MENU_H      = 16;
const int MENU_CURSEX = ( MENU_UPX + 8 );       ///////////////////////////////////////////////////
const int MENU_CURSEY = ( MENU_UPY + 3 );       

// difficulty/name entry screen reference points 
const int NAME_SCR_UPX = 0;
const int NAME_SCR_UPY = 0;
const int NAME_SCR_W   = 10;
const int NAME_SCR_H   = 20;

// game object and related constants
const char PLAYER      = '*';
const char CLOAK       = char(247);
const char HOLE        = char(178); 
const char TREASURE    = char(232);
const char SWORD       = char(157);
const char MONSTER     = char(206);
const char SPELL       = char(234);
const char IN_WALL     = char(176);
const char OUT_WALL    = char(176);
const char UP_STAIR    = 'U';
const char DWN_STAIR   = 'D';
const int EASY_DIFF    = 5;
const int MED_DIFF     = 3;
const int HARD_DIFF    = 1;
const int DEFAULT_DIFF = EASY_DIFF;
const int MAX_WALLS    = 75;

// typical character constants
const char NULL_CHAR = '\\0';
const char SPACE     = ' ';
const char NEW_LINE  = '\\n';

// game area constants
const int PLAY_AR_W    = 62;              ///////////////////////////////
const int PLAY_AR_H    = 23;              ///////////////////////////////
const int SCOREBOARD_W = 16;
const int SCOREBOARD_H = 25;
const int SCORE_X      = 14;
const int MESS_UPX     = 2;               
const int MESS_UPY     = 20;              ///////////////////////////////
const int MESSAGE_W    = 13;
const int MESSAGE_H    = 13;
const int GAMESTART_X  = 32;     // in gameMatrix coordinates                  
const int GAMESTART_Y  = 1 ;     // in gameMatrix coordinates                  

// probabilities
const int P_HOLE      = 35;
const int P_CLOAK     = 10; 
const int P_TREASURE  = 5 ;
const int P_SWORD     = 10;
const int P_MONSTER   = 25;
const int P_SPELL     = 10;

// c-style string lengths
const int NAME_LEN = 15;

// file names
const char FLOOR1[ NAME_LEN ] = ""lowlevel.txt"";
const char FLOOR2[ NAME_LEN ] = ""midlevel.txt"";
const char FLOOR3[ NAME_LEN ] = ""highlevel.txt"";
const char SCORES[ NAME_LEN ] = ""scores.txt"";

////////////////////////////////////////////////////////////////////////////////
// Global Function Prototypes //////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/*
  Name: dispSplash
  Process: Displays the splash screen, holds until button is pressed
  Function Input/Parameters: none
  Function Output/Parameters:None 
  Function Output/Returned: None
  Device Input: none
  Device Output/Monitor: Displays Title, and developers' names
  Dependencies: formatted_console_io_v18, curses
  Developer: Nicholas Smith
*/
char dispSplash ();


/* 
Name: printASCIIart
Process: prints one character as ASCII art at the entered position, or moves the
         cursor position depending on the parameter value entered
Function Input/Parameters: the character to be printed (char), the current or desired
                           cursor coordinates (int)
Function Output/Parameters: none
Function Output/Returned: none
Device Input: none
Device Output: displays an ASCII art character on the screen
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
void printASCIIart( char letter, int &currX, int &currY);


/* 
Name: dispInstructions
Process: displays an instruction screen for the game, varies depending on which
         game mode is active
Function Input/Parameters: a flage indicating whether or not extra credit mode has 
                           been activated (bool)
Function Output/Parameters: none
Function Output/Returned: none
Device Input: none
Device Output: displays the appropriate instruction screen
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
void dispInstructions( bool xMode );


/*
  Name: readHiScores
  Process: If file excits it reads the file in to be used later
  Function Input/Parameters: none
  Function Output/Parameters: none
  Function Output/Returned: none
  Device Input: none
  Device Output: none
  Dependencies: none
  Developer: Nicholas Smith
*/
void readHiScores ( char names[ NAME_LEN ], int scores[] );


/* 
Name: printMenuText
Process: displays the text of the menu, captures the menu option that the user 
         chooses 
Function Input/Parameters: none
Function Output/Parameters: none
Function Output/Returned: returns the user's menu selection (char)
Device Input: user's menu selection (char)
Device Output: displays the menu text
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
char printMenuText();


/* 
Name: setDiff
Process: displays the difficulty setting screen, collects the user's choice, converts
         that choice into a meaningful term for the program
Function Input/Parameters: none
Function Output/Parameters: none
Function Output/Returned: a wait time corresponding to the difficulty chosen by the 
                          user 
Device Input: the user's difficulty selection (int)
Device Output: displays the set difficulty screen
Dependencies: formatted_console_io_v18
Developer: Terence Henriod
*/
int setDiff();


/* 
Name: promptForPlayer
Process: displays the player name entry screen and collects the player name
Function Input/Parameters: (by reference) a c-style string to contain the entered
                           name
Function Output/Parameters: (by reference) a c-style string containing the entered player name
Function Output/Returned: none
Device Input: prompts for the player name
Device Output: displays the player name entry screen
Dependencies: formatted)console_io_v18, curses
Developer: Terence Henriod
*/
void promptForPlayer( char name[ NAME_LEN ] );


/* 
Name: executeGame
Process: carries out all processes associated with game play
Function Input/Parameters: the extra credit mode flag (bool), (by reference) the
                           score currently acheived by the player (int), the difficulty
                           the game will be played at
Function Output/Parameters: (by reference) the score achieved by the player
Function Output/Returned: function ends by returning zero
Device Input: gameplay actions (managed by movePlayer)
Device Output: outputs the gameplay to the screen
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
int executeGame( bool xcMode, int &score, int difficulty );


/*
  Name: isFileThere
  Process: Checks to see if level file is there
  Function Input/Parameters: file name, ifstream object
  Function Output/Parameters: none
  Function Output/Returned: Bool, whethier or not file is there
  Device Input: none
  Device Output: none
  Dependencies: none
  Developer: Nicholas Smith
*/
bool isFileThere ( const string &fileName );


/* 
Name: fileMissingMessage
Process: if level files are missing before gameplay starts, a message is displayed
         notifying the user why the program will not continue
Function Input/Parameters: none
Function Output/Parameters: none
Function Output/Returned: none
Device Input: none
Device Output: the ""level file missing"" message, written on the previously created
               screen promptForPlayer screen 
Dependencies: none
Developer: Terence Henriod
*/
void fileMissingMessage();


/* 
Name: makeScoreBoard
Process: initialized the scoreboard portion of the gameplay screen, differs slightly
         depending on game mode
Function Input/Parameters: the extra credit flag (bool)
Function Output/Parameters: none
Function Output/Returned: none
Device Input: none
Device Output: displays the initial scoreboard
Dependencies: formatted_console_io_v18
Developer: Terence Henriod
*/
void makeScoreBoard( bool xcMode );


/*
  Name: makeOutWall
  Process: Creates the outside wall of the game
  Function Input/Parameters: Width of the wall, heigh of the wal
  Function Output/Parameters: none
  Function Output/Returned: non
  Device Input: none
  Device Output: The wall around the board
  Dependencies: none  
  Developer: Nicholas Smith 
*/ 
void makeOutWall( int width, int height );


/* 
Name: clearMatrix
Process: loads the entire gameplay array with only spaces
Function Input/Parameters: (by reference) the gameplay matrix (short)
Function Output/Parameters: (by reference) the gameplay matrix (short)
Function Output/Returned: none
Device Input: none
Device Output: none
Dependencies: none
Developer: Terence Henriod
*/
void clearMatrix( short matrix[PLAY_AR_W][PLAY_AR_H] );


/* 
Name: setFloor
Process: loads the game matrix with walls, stairs and empty space; sets the player 
         at the start position
Function Input/Parameters: the floor number the player is heading to (int), (by reference)
                           the gameplay matrix (short)
Function Output/Parameters: (by reference) the gameplay matrix (short)
Function Output/Returned: none
Device Input: none
Device Output: displays a refreshed gameplay area on the screen
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
void setFloor( int floorNumber, short playMatrix[PLAY_AR_W][PLAY_AR_H] );



/* 
Name: readFloorData
Process: reads the interior wall layout into the program
Function Input/Parameters: the name of the file level to be read in (c-style string),
                           the two arrays that will hold the coordinates of the 
                           interior wall placements (int[]
Function Output/Parameters: (by reference) the two arrays that will hold the coordinates 
                            of the interior wall placements (int[]
Function Output/Returned: none
Device Input: none
Device Output: none
Dependencies: <fstream>
Developer: Terence Henriod
*/
int readFloorData( const char fileName[], int Xcoordinates[], int Ycoordinates[] );


/* 
Name: genObjectAt
Process: generates a specified object at the specified location in the game matrix,
         then prints that object on the screen 
Function Input/Parameters: the coordinates where the object should be generated in 
                           the gameplay matrix (int), the character object to be 
                           generated (short), (by reference)the gameplay matrix (short)
Function Output/Parameters: (by reference)the gameplay matrix (short)
Function Output/Returned: none
Device Input: none
Device Output: none
Dependencies: none
Developer: Terence Henriod
*/
void genObjectAt( int Xcoord, int Ycoord, short object, short playMatrix[PLAY_AR_W][PLAY_AR_H] );


/* 
Name: matrixToScreen
Process: takes a set of gameplay matrix coordinates, and takes the object stored in that 
         location, and outputs that object in the appropriate location on the screen
Function Input/Parameters: game matrix coordinates (int), the gameplay matrix (short)
Function Output/Parameters: none
Function Output/Returned: none
Device Input: none
Device Output: displays the item in the gamematrix to the screen
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
void matrixToScreen(int matrixX, int matrixY, short playMatrix[PLAY_AR_W][PLAY_AR_H] );


/* 
Name: keepScore
Process: recalculates the score and updates the score board appropriately for 
         the current game mode
Function Input/Parameters: the extra credit mode flag (bool), the item tallies (int),
                           (by reference) the current player score (int)
Function Output/Parameters: (by reference) the current player score (int)
Function Output/Returned: none
Device Input: none
Device Output: updates item tallies and the score on the scoreboard
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
void keepScore( bool xcMode, int cloaks, int swords, int spells, int treasure, int &score );


/*
  Name: movePlayer
  Process: Decided were to move
  Function Input/Parameters: time it takes to run loop
  Function Output/Parameters: none
  Function Output/Returned: none
  Device Input: none
  Device Output: none
  Dependencies: function: move
  Developer: Nicholas Smith
*/
void movePlayer ( int waitTime, bool &continueProgram );


/* 
Name: collisionTest
Process: if a ""collision"" between the player an a game item is about to occur,
         the function lets the movement function know if the player is allowed to move
         and if the game should continue, nad updates item tallies as appropriate
Function Input/Parameters: item tallies (int), the game matrix coordinates the player
                           is about to move into (int) the gameplaymatrix (short[][]),
                           and the flag indicating if gameplay should be allowed to
                           continue 
Function Output/Parameters: (by reference) the item tallies (int), the ""continue game""
                            flag (bool)
Function Output/Returned: the decision of whether or not the player should be allowed
                          to move (bool)
Device Input: none
Device Output: none
Dependencies: none
Developer: Nicholas Smith & Terence Henriod
*/
bool collisionTest( int &cloakTally,  int &swordTally,  int &spellTally, int &treasureTally,
                    int intendedX, int intendedY, short playMatrix[PLAY_AR_W][PLAY_AR_H], bool &continueGame );


/*
  Name: move
  Process: Moves the player inside the game area
  Function Input/Parameters: initial x & y positions, and the way the peice is moving
  Function Output/Parameters: none
  Function Output/Returned: none
  Device Input: none
  Device Output: none
  Dependencies: none
  Developer: Nicholas Smith
*/
bool move( int &xPos, int &yPos, int xVect, int yVect );


/* 
Name: screenToMatrix
Process: if something changes on the screen (i.e. the player moves), updates the 
         game matrix accordingly
Function Input/Parameters: the screen coordinates the object was displayed at (int),
                           the object that was put on the screen (short), (by reference)
                           the gameplay matrix (short[][])
Function Output/Parameters: (by reference) the gameplay matrix (short[][])
Function Output/Returned: none
Device Input: none
Device Output: none
Dependencies: none
Developer: Terence Henriod
*/
void screenToMatrix( int screenX, int screenY, short object, short playMatrix[PLAY_AR_W][PLAY_AR_H] );


/* 
Name: genObjects
Process: decides whether or not to generate activated game objects (i.e. items, dangers),
         and then generates them in free spaces both on the game board and the screen
Function Input/Parameters: the extra credit mode flag (bool), (by reference) the 
                           gameplay matrix (short[][])
Function Output/Parameters: by reference) the gameplay matrix (short[][])
Function Output/Returned: none
Device Input: none
Device Output: displays the generated objects on the screen
Dependencies: none
Developer: Terence Henriod
*/
void genObjects( bool xcMode, short gameBoard[ PLAY_AR_W ][ PLAY_AR_H ] );


/*
  Name: XYPos
  Process: Generate x and y position to be used for item placement
  Function Input/Parameters: x and y positions as a reference
  Function Output/Parameters: x y postions
  Function Output/Returned: none
  Device Input: none
  Device Output: none
  Dependencies: spaceOccupied, rand()
  Developer: Nicholas Smith
*/
void XYPos ( int &xPos, int &yPos );


/*
  Name: spaceOccupied
  Process: takes a x & y corridnate and runs them through the matrix 
	   checking to see if that spot is occupied
  Function Input/Parameters: x & y position, and matrix
  Function Output/Parameters: none
  Function Output/Returned:Bool, true if nothing is there, false it there is something in that spot
  Device Input: none
  Device Output: none
  Dependencies: none
  Developer: Nicholas Smith
*/
bool spaceOccupied ( int XPos, int YPos, short playMatrix[PLAY_AR_W][PLAY_AR_H]);


/* 
Name: doGenObject
Process: makes a decision whether or not to generate an object based of an integer
         number chance in 100
Function Input/Parameters: the chance in 100 an item should be generated (int)
Function Output/Parameters: none
Function Output/Returned: the decision whether or not to generate that item (bool)
Device Input: none
Device Output: none
Dependencies: none
Developer: Nicholas Smith
*/
bool doGenObject( int chancein100 );


/* 
Name: get_Random_Number
Process: produces a random number in the input range
Function Input/Parameters: the low and high ends of the desired range (int)
Function Output/Parameters: none
Function Output/Returned: a random number in the desred range
Device Input: none
Device Output: none
Dependencies: random number generator
Developer: Nicholas Smith
*/
int get_Random_Number(int low_Value, int high_Value);


/* 
Name: gameOverMessage
Process: displays the game over message on the scoreboard
Function Input/Parameters: none
Function Output/Parameters: none
Function Output/Returned: none
Device Input: none
Device Output: displays the game over message on the scoreboard
Dependencies: formatted_console_io_v18, curses
Developer: Terence Henriod
*/
void gameOverMessage();


/*
  Name: writeScoreFile
  Process: writes scores into file after game has been played
  Function Input/Parameters: name of players and scores (array)
  Function Output/Parameters: none
  Function Output/Returned: none
  Device Input: none
  Device Output: none
  Dependencies: sortScores
  Developer: Nicholas Smith
*/
void writeScoreFile( char names[ NAME_LEN ], int scores[], int candidate );


/*
  Name: sortScores
  Process: sorts the scores from highest to lowest, only has ten
  Function Input/Parameters: name of players, scores for players, new score to be sorted
  Function Output/Parameters: none
  Function Output/Returned:none
  Device Input: none
  Device Output: none
  Dependencies: noen
  Developer: Nicholas Smith
*/
void sortScores( char names[ NAME_LEN], int scores[], int candidate);


/*
  Name: showHiScores
  Process: When selected, the scores will be shone from the file
  Function Input/Parameters: 
  Function Output/Parameters: none
  Function Output/Returned: 
  Device Input: none
  Device Output: Top ten hi scores in order
  Dependencies: readScores, sortScores, writeScoreFile
  Developer: Nicholas Smith
*/
void showHiScores ( char names[], int scores[] );


////////////////////////////////////////////////////////////////////////////////
// Main Program Definition /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

int main()
   { 
// initialize variables

   // arrays and matrices
   char playerName[NAME_LEN];
   char names[NAME_LEN];
   int scores[NAME_LEN];
 
   // user input variables
   int userInput;

   // game related variables 
   int score = 0;
   int difficulty = DEFAULT_DIFF;

   // flags
   bool XCmode = true;
   bool keepRunning = true;

   // random seed
   srand( time( NULL ) );  


// initialize program

   // initialize curses
      // functions: startCurses, setColor
      startCurses();
      setColor( COLOR_WHITE, COLOR_BLACK, SET_BRIGHT );

// display splash screen
   // function: dispSplash
   userInput = dispSplash();

   // if 'E' was pressed, activate extra credit mode
      // operation: if
      if( userInput == 'E' || userInput == 'e' )
        {
        // set extra credit mode flag
        XCmode = true;
        }

// display instructions screen (the plan is to run the game in extra credit mode by default)
   // function: dispInstructions
   dispInstructions( XCmode );

// read in high scores, if file is present, ensure arrays are clean 
   // function: readScores
   readHiScores( names, scores );

// implement menu (loop until valid option is chosen)
   // operation: while
  while( keepRunning ) 
     {
     // display menu
        // clear screen
           // function: setColor, clearScreen
           setColor( COLOR_WHITE, COLOR_BLACK, SET_BRIGHT);
           clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) );
           setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT);
           clearScreen( MENU_UPX, MENU_UPY, (MENU_UPX + MENU_W), (MENU_UPY + MENU_H) );         

     // display menu text
        // function: printMenuText
        userInput = printMenuText();

          // operation: switch
          switch( userInput )
             {
             // case: set difficulty
             case '1':
             case 'D':
             case 'd':
                {
                // function: setDiff
                difficulty = setDiff();
                }
                break;

             // case: play the game
             case '2':
             case 'P':
             case 'p':
                {
                // get player name
                   // function: promptForPlayer
                   promptForPlayer( playerName );

                // play the game!
                  // function: executeGame
                  executeGame( XCmode, score, difficulty );

                // write high score file
                  // function: writeScores
                  writeScoreFile( names, scores, score );
                }
                break;

             // case: show high scores
             case '3':
             case 'S':
             case 's':
                {
                // function: showHiScores
                showHiScores( names, scores );
                }
                break;

             // case: quit program  
             case '4':
             case 'Q':
             case 'q':
                {
                // set flag such that menu loop ends
                keepRunning = false;
                }
                break;
             }
      }
// end the program
   
   // shut down curses
      // function: endCurses
      endCurses();

   // return 0           
   return 0;
   }


////////////////////////////////////////////////////////////////////////////////
// Supporting function implementations /////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

char dispSplash ()
    {
    // Initialize Variables
       // Set initial x & y positions

       // Set other Variables


    // Set color for Title and Background
       // Funtion: setColor


    // Clear screen
       // Function: clearScreen


    // Display Title
       // printStringAt || printCharAt

    // Display Developer's Names
       // Change x & y positions

    // Hold Screen For User
       // Change x & y postions

       // print string to tell user what to do
	  // printStringAt
       
       // Hold screen by prompting for char
          // promptForCharAt

    // return input
    return 0;     // temporary stub return
    }


void printASCIIart( char letter, int &currX, int &currY)
   {
   // variables
     

   // decide which ASCII art character to display 
    switch( letter )
      {
      // print art E
       case 'E':
       case 'e':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, "" EEEEEEEE "", ""LEFT"" );
             
            // second line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" EE     E "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" EEEE     "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" EEEE     "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" EE     E "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" EEEEEEEE "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art G
       case 'G':
       case 'g':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, ""  GGGGGGG  "", ""LEFT"" );             
             
            // second line of letter
               // function:printStringAt
               currX -= 11;
               currY ++;
               printStringAt( currX, currY, "" GGG    GG "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 11;
               currY ++;
               printStringAt( currX, currY, "" GG        "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 11;
               currY ++;
               printStringAt( currX, currY, "" GG   GGGG "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -=11;
               currY ++;
               printStringAt( currX, currY, "" GGG    GG "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 11;
               currY ++;
               printStringAt( currX, currY, ""  GGGGGGG  "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art I
       case 'I':
       case 'i':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, "" IIII "", ""LEFT"" ); 
          
             // second line of letter
               // function:printStringAt
               currX -= 6;
               currY ++;
               printStringAt( currX, currY, ""  II  "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 6;
               currY ++;
               printStringAt( currX, currY, ""  II  "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 6;
               currY ++;
               printStringAt( currX, currY, ""  II  "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 6;
               currY ++;
               printStringAt( currX, currY, ""  II  "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 6;
               currY ++;
               printStringAt( currX, currY, "" IIII "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art K
       case 'K':
       case 'k':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, "" KK  KK  "", ""LEFT"" );
             
            // second line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" KK KK   "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" KK K    "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" KKKKK   "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" KK  KK  "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" KK   KK "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art L
       case 'L':
       case 'l':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, "" LL      "", ""LEFT"" );
             
            // second line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" LL      "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" LL      "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" LL      "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" LL      "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" LLLLLLL "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art O
       case 'O':
       case 'o':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, ""  OOOOOO  "", ""LEFT"" );
            
            // second line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" OOO  OOO "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" OO    OO "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" OO    OO "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" OOO  OOO "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, ""  OOOOOO  "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art R
       case 'R':
       case 'r':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, "" RRRRRR  "", ""LEFT"" );
             
            // second line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" RR   RR "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" RR   RR "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" RRRRRR  "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" RR RR   "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 9;
               currY ++;
               printStringAt( currX, currY, "" RR  RR  "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // print art U
       case 'U':
       case 'u':
            {
            // first line of letter
               // function:printStringAt
               printStringAt( currX, currY, "" UU    UU "", ""LEFT"" ); 
            
            // second line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" UU    UU "", ""LEFT"" );

            // third line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" UU    UU "", ""LEFT"" );

            // fourth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" UU    UU "", ""LEFT"" );

            // fifth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, "" UUU  UUU "", ""LEFT"" );

            // sixth line of letter
               // function:printStringAt
               currX -= 10;
               currY ++;
               printStringAt( currX, currY, ""  UUUUUU  "", ""LEFT"" );

            // position cursor for next letter
               currY -= 5;
            }
            break;

      // move to a new line
       case NEW_LINE:
            {
            // increment the xy and y cursor positions accordingly 
               currX =   5;
               currY -= 40;
            }
            break;
      }

   // no return - void
   }


void dispInstructions( bool xMode )
   {
   // variables
   int xPos = SCR_CENTER;
   int yPos = (INSTR_UPY + 1);

   // paint gray background
      // functions: setColor, clearScreen
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      clearScreen( INSTR_UPX, INSTR_UPY, (INSTR_UPX + INSTR_W), (INSTR_UPY + INSTR_H) );

      // paint a bigger background if extra credit mode is enabled
         // operation: if
         if( xMode )
           {
           //function: clearScreen
            clearScreen( INSTR_UPX, (INSTR_UPY + INSTR_H), (INSTR_UPX + INSTR_W), (INSTR_UPY + INSTR_H + 4) );
           }

   // write title line w/ underline
      // functions: printStringAt
      printStringAt( xPos, yPos, ""Rogue-Like Instructions"", ""CENTER"" );
      xPos = SCR_CENTER, yPos ++;
      printStringAt( xPos, yPos, ""======================="", ""CENTER"" );
      yPos += 2;

   // write cloak/hole info
      // functions: printStringAt, setColor, printSpecialCharAt
      xPos = (INSTR_UPX + 2); 
      printStringAt( xPos, yPos, ""Green"", ""LEFT"" );
      xPos += 6;
      setColor( COLOR_GREEN, COLOR_WHITE, SET_BRIGHT );
      printSpecialCharAt( xPos, yPos, CLOAK );
      xPos ++;
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      printStringAt( xPos, yPos, "" are magic cloaks that can cover holes"", ""LEFT"" );
      xPos += 39;
      setColor( COLOR_RED, COLOR_WHITE, SET_BRIGHT );
      printSpecialCharAt( xPos, yPos, HOLE );
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      yPos += 2;

   // if game is in extra credit mode, display extra credit info
      // operation: if
      if( xMode )
        {
        // write sword/monster info
           // functions: printStringAt, setColor, printSpecialCharAt
           xPos = (INSTR_UPX + 6); 
           printStringAt( xPos, yPos, ""Green"", ""LEFT"" );
           xPos += 6;
           setColor( COLOR_GREEN, COLOR_WHITE, SET_BRIGHT );
           printSpecialCharAt( xPos, yPos, SWORD );
           xPos ++;
           setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
           printStringAt( xPos, yPos, "" are swords that kill monsters"", ""LEFT"" );
           xPos += 31;
           setColor( COLOR_RED, COLOR_WHITE, SET_BRIGHT );
           printSpecialCharAt( xPos, yPos, MONSTER );
           setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
           yPos += 2;

        // write spell/wall info
           // functions: printStringAt, setColor, printSpecialCharAt
           xPos = (INSTR_UPX + 5); 
           printStringAt( xPos, yPos, ""Green "", ""LEFT"" );
           xPos += 6;
           setColor( COLOR_GREEN, COLOR_WHITE, SET_BRIGHT );
           printSpecialCharAt( xPos, yPos, SPELL );
           xPos ++;
           setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
           printStringAt( xPos, yPos, "" are spells that go through walls"", ""LEFT"" );
           xPos += 34;
           setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
           printSpecialCharAt( xPos, yPos, IN_WALL );
           setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
           yPos += 2;
        }

   // write treasure info
      // functions: printStringAt, setColor, printSpecialCharAt
      xPos = (INSTR_UPX + 12); 
      printStringAt( xPos, yPos, ""Yellow"", ""LEFT"" );
      xPos += 7;
      setColor( COLOR_YELLOW, COLOR_WHITE, SET_BRIGHT );
      printSpecialCharAt( xPos, yPos, TREASURE );
      xPos ++;
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      printStringAt( xPos, yPos, "" are golden treasure"", ""LEFT"" );
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      yPos += 2;

   // write stair info
      // functions: setColor, printCharAt, printStringAt
      xPos = (INSTR_UPX + 8); 
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      printCharAt( xPos, yPos, DWN_STAIR );
      xPos ++;  
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      printStringAt( xPos, yPos, "" and"", ""LEFT"" );
      xPos += 5;
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      printSpecialCharAt( xPos, yPos, UP_STAIR );
      xPos ++;
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      printStringAt( xPos, yPos, "" lead to Upper and Lower floors"", ""LEFT"" );
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
      yPos += 2;      

   // write condition(s) for ending the game
      // functions: printStringAt
      xPos = (INSTR_UPX + 20);
      printStringAt( xPos, yPos, ""Hitting a hole"", ""RIGHT"" );
      xPos ++;
   
      // if extra credit mode is active
         // operation: if
         if( xMode )
           {
           // print any extra conditions
              // function: printStringAt
              printStringAt( xPos, yPos, "" or a monster"", ""LEFT"" );
              xPos += 14;          
           }

    // finish the game end condition statement
       // function: printString
       printStringAt( xPos, yPos, ""ends the game"", ""LEFT"" );
       yPos += 2;       

   // write object of game message
      // functions: printStringAt
      xPos = (INSTR_UPX + 6);
      printStringAt( xPos, yPos, ""Try to keep moving for as long as possible"", ""LEFT"" );
      yPos += 2;
      xPos = (INSTR_UPX + 5);
      printStringAt( xPos, yPos, ""More treasure and weapons get a better score"", ""LEFT"" );

   // hold the system for the user
      // function: waitForInput
      waitForInput( FIXED_WAIT );     

   // no return - void 
   }


void readHiScores ( char names[ NAME_LEN ], int scores[] )
   {
    // Initalize Variables
    
    // Loop to read in files, go until index < 11 || fin !.good
   
       // read in name into array
      
       // read in score into array

       // update index 

   }


char printMenuText()
   {
   // set cursor position/variables
   int xLoc = MENU_CURSEX;
   int yLoc = MENU_CURSEY;
   char input = '+';

   // menu title
      // function: printStringAt
      printStringAt( xLoc, yLoc, ""MENU SELECTIONS"", ""LEFT"" );
      xLoc = MENU_CURSEX;
      yLoc ++;
      printStringAt( xLoc, yLoc, ""---------------"", ""LEFT"" );           

   // option 1
      // function: printStringAt
      xLoc = MENU_CURSEX;
      yLoc += 2;
      printStringAt( xLoc, yLoc, ""1. Set <D>ifficulty"", ""LEFT"" );

   // option 2
      // function: printStringAt
      xLoc = MENU_CURSEX;
      yLoc ++;
      printStringAt( xLoc, yLoc, ""2. <P>lay Game"", ""LEFT"" );

   // option 3
      // function: printStringAt
      xLoc = MENU_CURSEX;
      yLoc ++;
      printStringAt( xLoc, yLoc, ""3. <S>how Top Scores"", ""LEFT"" );

   // option 4
      // function: printStringAt
      xLoc = MENU_CURSEX;
      yLoc ++;
      printStringAt( xLoc, yLoc, ""4. <Q>uit program"", ""LEFT"" );

   // prompt for user input
      // function: promptForCharAt
      xLoc = MENU_CURSEX;
      yLoc += 2;
      input = promptForCharAt( xLoc, yLoc, ""Enter Selection: "" );

   // return the input entered by the user
   return 0;     // temporary stub return
   }


int setDiff()
   {
   // variables
   int input = DEFAULT_DIFF;
   int xPos = SCR_CENTER;
   int yPos = (NAME_SCR_UPY + 1);

   // clear screen to black, then a small area to blue
      // functions: setColor, clearScreen
      setColor( COLOR_WHITE, COLOR_BLACK, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) );
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) );

   // display ""screen title""
      // function: printStringAt
      printStringAt( xPos, yPos, ""Game Data Entry Module"", ""CENTER"" );

   // loop until proper entry is received
      // operation: while 
      while( input < 1 || input > 3 )
        {
      // display prompt
         // function: promptForIntAt
         yPos = (NAME_SCR_UPY + 4);
         xPos = (NAME_SCR_UPX + 4);
         input = promptForIntAt( xPos, yPos, ""Enter Game Difficulty (1-3): "" );
        }
   // convert user selection to meaningful program terms 
      // operation: switch
      switch( input )
        {  
        // case: easy ( 1 -> 5 )
        case 1:
             input = EASY_DIFF;
            break;

        // case: medium ( 2 -> 3 )
        case 2: 
             input = MED_DIFF;
            break;

        // case: hard ( 3 -> 1 )
        case 3:
             input = HARD_DIFF;
            break;
        }

   // return difficulty in meaningful program terms
   return input; 
   }


void promptForPlayer( char name[ NAME_LEN ] )
   {
   // variables
   int xPos = (NAME_SCR_UPX + 5);
   int yPos = (NAME_SCR_UPY + (NAME_SCR_H / 2));

   // clear screen to black, then a small area to blue
      // functions: setColor, clearScreen
      setColor( COLOR_WHITE, COLOR_BLACK, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) );
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) ); 
       
   // prompt for user name, storing the name in a C-style string
      // function: promptForStringAt (the void one)
      promptForStringAt( xPos, yPos, name );

   // no return - void
   }


int executeGame( bool xcMode, int &score, int difficulty )
   {
   // variables

      // game board matrix
      short gameBoard[PLAY_AR_W][PLAY_AR_H];
 
      // current floor and counters
      int cloaks   = 0;
      int swords   = 0;
      int spells   = 0;
      int treasure = 0;
      int curFloor = 2;

      // floor flags
      bool floor1present = false;
      bool floor2present = false;
      bool floor3present = false;
      int  goToFloor     = 2;

      // continue game flag
      bool keepPlaying = true;

   // check for floor files
      // function: isFileThere
      floor1present = isFileThere( FLOOR1 );
      floor2present = isFileThere( FLOOR2 );
      floor3present = isFileThere( FLOOR3 );

      // display error message and return user to menu if any files are missing
         // operation: if 
         if( !floor1present && !floor2present && !floor3present )
           {
            // display the error message
               // function: fileMissingMessage
               fileMissingMessage();              

            // end gameplay by returning 0 
            return 0;
           }

   // initialize score board
      // function: makeScoreBoard
      makeScoreBoard( xcMode );
  
   // place outer wall
      // function: makeOutWall 
      makeOutWall( (PLAY_AR_W + 2), (PLAY_AR_H + 2));

   // initialize game board
      // function: clearMatrix
      clearMatrix( gameBoard );

   // begin game loop
      // operation: while
      while( keepPlaying )
        {
        // set/reset floor if necessary
           // operation: if
           if( curFloor != goToFloor)
             {
              // function: setFloor
              setFloor( goToFloor, gameBoard);                       // also resets player position

              // set the current floor equal to the goToFloor flag
              curFloor = goToFloor;
             }

        // manage the scoreboard
           // function: keepScore              
           keepScore( xcMode, cloaks, swords, spells, treasure, score );

        // game object generation
           // function: genObjects
           genObjects( xcMode, gameBoard );

        // manage player movement 
           // function: movePlayer
           movePlayer( difficulty, keepPlaying );

        // loop breaks when condition to continue game becomes false
       }

   // display game over message
      // function: gameOverMessage
      gameOverMessage();

   // return zero to end game play
   return 0;          
   }


bool isFileThere ( const string &fileName )
     {
      // Initalize variables
      ifstream fin;	
      fin.clear();
      fin.open( fileName.c_str() );
      if ( !fin.good() )
         {
         printStringAt ( UPRLEFTX, UPRLEFTY, ""<<You have fallen into a pit of spikes. YOU ARE DEAD>>"", ""LEFT"" );
	 waitForInput(FIXED_WAIT);
         return false;
         }

       // close file if it was there 
          // function: .close
          fin.close();

       // return true to indicate file was there
       return true;     
      }

void fileMissingMessage()
   {
   // variables
   int xPos = (NAME_SCR_UPX + 4);
   int yPos = (NAME_SCR_UPY + 2);

   // clear screen to black, then clear a message box; uses promptForPlayer dimensions
      // functions: setColor, clearScreen
      setColor( COLOR_WHITE, COLOR_BLACK, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) );
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, (UPRLEFTX + SCR_W), (UPRLEFTY + SCR_H) );

   // print the error message on the screen
      // function: printStringAt
 
      // title line
      printStringAt( xPos, yPos, ""ERROR: Level File(s) Missing"", ""LEFT"" );
      xPos = (NAME_SCR_UPX + 2);
      yPos += 2;

      // main message
      printStringAt( xPos, yPos, ""One or more of the level files is missing;"", ""LEFT"" );
      xPos = (NAME_SCR_UPX + 2);
      yPos ++;
      printStringAt( xPos, yPos, ""Please ensure that the level files are in place."", ""LEFT"" );

   // move the cursor to the position where system hold message will be displayed
   xPos = (NAME_SCR_UPX + 4);
   yPos += 2;

   // print the holding message and hold the screen for the user
      // functions: printStringAt, waitForInput
      printStringAt( xPos, yPos, ""Press any key to continue . . ."", ""LEFT"" );
      waitForInput( FIXED_WAIT );      

   // no return - void
   }


void makeScoreBoard( bool xcMode )
   {
   //variables
   int xPos = (UPRLEFTX + 2);
   int yPos = (UPRLEFTY + 1);

   // paint scoreboard background
      // functions: setColor, clearScreen
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      clearScreen( UPRLEFTX, UPRLEFTY, SCOREBOARD_W, SCR_H );

   // print the title
     // function: printStringAt
     printStringAt( xPos, yPos, ""ROGUE - LIKE"", ""LEFT"" );

   // create tool item tallies, update cursor position
   xPos = (UPRLEFTX + 1);
   yPos += 2;              

      // cloak tally
         // functions: printStringAt, printIntAt
         printStringAt( xPos, yPos, ""Cloak:"", ""LEFT"" );
         printIntAt( (SCOREBOARD_W - 2), yPos, 0, ""LEFT"" );
         xPos = (UPRLEFTX + 1);
         yPos ++;      

      // extra credit item tallies if extra credit mode is active
         // operation: if
         if( xcMode ) 
           {
            // sword tally
               // functions: printStringAt, printIntAt          
               printStringAt( xPos, yPos, ""Sword:"", ""LEFT"" );
               printIntAt( (SCOREBOARD_W - 2), yPos, 0, ""LEFT"" );
               xPos = (UPRLEFTX + 1);
               yPos ++;
 
            // spell tally
               // functions: printStringAt, printIntAt
               printStringAt( xPos, yPos, ""Spell:"", ""LEFT"" );
               printIntAt( (SCOREBOARD_W - 2), yPos, 0, ""LEFT"" );
               xPos = (UPRLEFTX + 1);
               yPos ++;
           }

   // create treasure tally
      // functions: printStringAt, printIntAt
      xPos = (UPRLEFTX + 1);
      yPos ++;
      printStringAt( xPos, yPos, ""Treasure:"", ""LEFT"" );
      printIntAt( (SCOREBOARD_W - 2), yPos, 0, ""LEFT"" );
      xPos = (UPRLEFTX + 1);
      yPos += 2;

   // create score tally
      // functions: printStringAt, printIntAt
      xPos = (UPRLEFTX + 1);
      yPos ++;
      printStringAt( xPos, yPos, ""Score:"", ""LEFT"" );
      printIntAt( (SCOREBOARD_W - 2), yPos, 0, ""LEFT"" );

   // write game directions
   
      // movement directions
         // function: printStringAt
         xPos = (UPRLEFTX + 2);
         yPos += 2;
         printStringAt( xPos, yPos, ""Arrows set"", ""LEFT"" );
         xPos = (UPRLEFTX + 2);
         yPos ++;
         printStringAt( xPos, yPos, ""direction"", ""LEFT"" );

      // stair instructions
         // function: printStringAt
         xPos = (UPRLEFTX + 2);
         yPos += 2;
         printStringAt( xPos, yPos, ""Follow U/D"", ""LEFT"" );
         xPos = (UPRLEFTX + 2);
         yPos ++;
         printStringAt( xPos, yPos, ""to change"", ""LEFT"" );
         xPos = (UPRLEFTX + 2);
         yPos ++;
         printStringAt( xPos, yPos, ""level"", ""LEFT"" );

      // how the game ends
         // function: printStringAt
         xPos = (UPRLEFTX + 2);
         yPos += 2;
         printStringAt( xPos, yPos, ""Falling into"", ""LEFT"" );
         xPos = (UPRLEFTX + 3);
         yPos ++;
         printStringAt( xPos, yPos, ""a hole"", ""LEFT"" );
         xPos = (UPRLEFTX + 2);
         yPos ++;
         printStringAt( xPos, yPos, ""or pressing ESC"", ""LEFT"" );
         xPos = (UPRLEFTX + 3);
         yPos ++;
         printStringAt( xPos, yPos, ""ends game"", ""LEFT"" );

   // no return - void   
   }


void makeOutWall( int width, int height )
   {
    // initialize function/variables
    int counter;
    int leftUpperX = SCRN_MAX_X / 2 - width / 2;
    int leftUpperY = SCRN_MAX_Y / 2 - height / 2;
    int rightLowerX = leftUpperX + width - 1;
    int rightLowerY = leftUpperY + height - 1;

    // clear screen in shape of box
    clearScreen( leftUpperX, leftUpperY, rightLowerX, rightLowerY );

    // iterate from left to right across box
    for( counter = leftUpperX; counter < leftUpperX + width; counter++ )
       {
        // print top frame character
        printSpecialCharAt( counter, leftUpperY, OUT_WALL );

        // print bottom frame character
        printSpecialCharAt( counter, rightLowerY, OUT_WALL );
       }
    
    for( counter = leftUpperY; counter < leftUpperY + height; counter++ )
       {
        // print left frame character
        printSpecialCharAt( leftUpperX, counter, OUT_WALL );

        // print right frame character
        printSpecialCharAt( rightLowerX, counter, OUT_WALL );
       }
    }


void clearMatrix( short matrix[PLAY_AR_W][PLAY_AR_H] )
   {
   // variables
   int wIndex = 0;
   int hIndex = 0;

   // use loop to fill all positions in matrix with spaces
   // pick a row and fill it, then move on
      // operation: for
      for( hIndex = 0; hIndex < PLAY_AR_H; hIndex ++ )
         {
         // iterate through the row
            // operation: for
            for( wIndex = 0; wIndex < PLAY_AR_W; wIndex ++ )
               {
               // store a space to the current matrix position
               matrix[wIndex][hIndex] = SPACE;
               // loop ends when every position in row is filled
               }

         // loop ends when all columns have been visited 
         }

   // no return - void
   }


void setFloor( int floorNumber, short playMatrix[PLAY_AR_W][PLAY_AR_H] )
   {
   // variables
   int AxPos = 0;
   int AyPos = 0;
   int MxPos = 0;
   int MyPos = 0;
   int index  = 0;
   int xCoords[MAX_WALLS];
   int yCoords[MAX_WALLS];
   int numWalls = 0;

   // clear the play matrix output a cleared game board to the screen
      // function: clearMatrix
      clearMatrix( playMatrix );

   // output a cleared game board to the screen
      // operation: for, functions: setColor, matrixToScreen
      setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
/*
      for( )
        {
         for()
           {

           }
 */

   // load coordinate arrays depending on which floor is selected
      // operation: switch
      switch( floorNumber )
         {
         // case: floor 1
         case 1:
                // function: readFloorData
                numWalls = readFloorData( FLOOR1, xCoords, yCoords );
                break;

         // case: floor 2
         case 2: 
                // function: readFloorData
                numWalls = readFloorData( FLOOR2, xCoords, yCoords );
                break;

         // case: floor 3
         case 3:
                // function: readFloorData
                numWalls = readFloorData( FLOOR3, xCoords, yCoords );
                break;

         }

   // load walls into game matrix by looping through coordinates until the walls have been ""used up""
      // operation: for
      for( index = 0; index < numWalls; index ++ )
         {
         playMatrix[ xCoords[index] ][ yCoords[index] ] = IN_WALL;
         }

   // reload player into matrix
   playMatrix[GAMESTART_X][GAMESTART_Y] = PLAYER; 

   // reload stairs, depending on level
      // operation: switch
      switch( floorNumber )
         {
         // case: setting floor 1 (only up stairs)
         case 1:
               // function: genObjectAt
             // genObjectAt();
              break;
  
         // case: setting floor 2 (both stairs)
         case 2:
               // function: genObjectAt
               
               break;
         // case: setting floor 3 (only down stairs)
         case 3:
               // function: genObjectAt
 
               break;
         }

   // output walls to display, again by looping
      // operation: for
      for( index = 0; index < numWalls; index ++ )
         {      
         // use coordinates stored in X and Y arrays to output walls stored in matrix to display
            // functions: setColor, matrixToScreen  
            setColor( COLOR_BLUE, COLOR_WHITE, SET_BRIGHT );
            matrixToScreen( xCoords[index], yCoords[index], playMatrix );
         }

   // output player to screen
      // functions: setColor, matrixToScreen
      setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
      matrixToScreen( GAMESTART_X, GAMESTART_Y, playMatrix );

   // output stairs to screen
      // operation: switch
      switch( floorNumber )
         {
         // case: setting floor 1 (only up stairs)
 
                // function: setColor, matrixToScreen

         // case: setting floor 2 (both stairs)

                // function: setColor, matrixToScreen

         // case: setting floor 3 (only down stairs)

                // function: setColor, matrixToScreen
         }
   // no return - void
   } 
 

int readFloorData( const char fileName[], int Xcoordinates[], int Ycoordinates[] )
   {
   // variables

   // clear fstream object, open the floor file

   // use loop to read the floor pattern data into the coordinate arrays
      // operation: for

         // read an x coordinate, then a y coordinate

   // when the loop breaks, the index will indicate the number of walls read in, store it

   // close the file

   // return the number of walls
   return 0;     // temporary stub function
   }


void genObjectAt( int Xcoord, int Ycoord, short object, short playMatrix[PLAY_AR_W][PLAY_AR_H] )
   {
   // place object in matrix

   // animate object on screen
      // function: matrixToScreen

   // no return - void
   } 


void matrixToScreen(int matrixX, int matrixY, short playMatrix[PLAY_AR_W][PLAY_AR_H] )
   {
   // variables
   int xPos;
   int yPos;
 
   // convert matrix x and y coordinates to screen coordinates
   xPos = (matrixX + SCOREBOARD_W + 1);
   yPos = (matrixY + 1);

   // print the object in the matrix to the screen
      // function: printSpecialCharAt
      printSpecialCharAt( xPos, yPos, playMatrix[matrixX][matrixY] );

   // no return - void
   }


void keepScore( bool xcMode, int cloaks, int swords, int spells, int treasure, int &score )
   {
   // variables
   int xPos = (SCOREBOARD_W - 2);
   int yPos = 5;

   // update item tallies

      // cloak tally
         // function: printIntAt
         printIntAt( xPos, yPos, cloaks, ""LEFT"" );
         yPos ++;

      // extra credit items if extra credit mode is active
         // operation: if
         if( xcMode )
           {
            // sword tally
               // function: printIntAt 
               printIntAt( xPos, yPos, swords, ""LEFT"" );
               yPos ++;
             
            // spell tally
               // function: printIntAt
               printIntAt( xPos, yPos, spells, ""LEFT"" );
               yPos ++;
           }

      // treasure tally
         // function: printIntAt
         yPos ++;
         printIntAt( xPos, yPos, treasure, ""LEFT"" );
         yPos ++;


   // re-calculate score, if extra credit mode is inactive, extra credit item tallies will be zero
      // operation: math
      score = ( cloaks + swords + spells + (5 * treasure) );

   // update score
      // function: printIntAt
         yPos ++;
         printIntAt( xPos, yPos, score, ""LEFT"" );
         yPos ++;

   // no return - void 
   }


void movePlayer ( int waitTime, bool &continueProgram )
    { 
    // Initialize variables
       int xLoc, yLoc, xVector, yVector;
      

       // initialize locations and movement vectors
       xLoc = PLAY_AR_W / 2;
       yLoc = PLAY_AR_H / 2;
       xVector = 0; yVector = 0;
    do
       {
        // if user input, set direction, otherwise ignore
        switch( waitTime )
           {
            case KB_RIGHT_ARROW:
               xVector = 1;
               yVector = 0;
               break;

            case KB_LEFT_ARROW:
               xVector = -1;
               yVector = 0;
               break;
 
            // set up a case for moving up with the up arrow key
        
            case KB_UP_ARROW:
               xVector = 0;
               yVector = -1;
               break;    

            // set up a case for moving down with the down arrow key
            case KB_DOWN_ARROW:
               xVector = 0;
               yVector = 1;
               break;

            // set up a case for moving down with the down arrow key
            case KB_ESCAPE:
               continueProgram = false;
               break;
            }

        // decide if player can move into next spot
           // operation: if

              // if collisionTest allows, move the character
              move( xLoc, yLoc, xVector, yVector );

              // otherwise, player is not allowed to move
       }
        while( continueProgram );

// no return - void
}


bool collisionTest( int &cloakTally,  int &swordTally,  int &spellTally, int &treasureTally,
                    int intendedX, int intendedY, short playMatrix[PLAY_AR_W][PLAY_AR_H], bool &continueGame )
   {
   // test new player position, if space, allow player to move
      // operation: if; function: spaceOccupied 

   // else, program responds accordingly
      // operations: else, switch

          // case: Hole
             
             // test to see if requisite tool is present
                // operation: if, else

                   // if not enough of tool, return signal to stop movement and end game
                

                // otherwise, decrement item tally

          // case: Monster
             
             // test to see if requisite tool is present
                // operation: if, else

                   // if not enough of tool, return signal to stop movement and end game
                

                // otherwise, decrement item tally       

          // case: Wall
             
             // test to see if requisite tool is present
                // operation: if, else

                   // if not enough of tool, return signal to stop movement
                

                // otherwise, decrement item tally

          // case: cloak
             
             // set flag to allow movement, increment item tally

          // case: sword
             
             // set flag to allow movement, increment item tally

          // case: spell
             
             // set flag to allow movement, increment item tally

          // case: treasure
             
             // set flag to allow movement, increment item tally

   // return movement decision if it hasn't been already
   return 0;     // temporary stub return 
   }


bool move( int &xPos, int &yPos, int xVect, int yVect )
   {
    // initialize function/variables
    bool moved = false;
    int oldX = xPos, oldY = yPos;

    // if x vector is live, test for acceptable movement limits
    if( ( xVect != 0 ) // is meant to move
          && ( xPos + xVect >= SCRN_MIN_X ) // won't go off left side of screen 
               && ( xPos + xVect <= SCRN_MAX_X )  ) // won't go off right side of screen
       {
        // cover up the old marker
	setColor( COLOR_BLACK, COLOR_WHITE, SET_BRIGHT );
        printCharAt( oldX, oldY, SPACE );

        // reset the x position
        xPos = xPos + xVect;

        // set moved flag to indicate success
        moved = true;
       }

    // if y vector is live, test for acceptable movement limits
    else if( ( yVect != 0 ) // is meant to move
               && ( yPos + yVect >= SCRN_MIN_Y ) // won't go off top of screen
                    && ( yPos + yVect <= SCRN_MAX_Y ) ) // won't go off bottom of screen
       {
        // cover up the old marker
	setColor( COLOR_BLACK, COLOR_WHITE, SET_BRIGHT );
        printCharAt( oldX, oldY, SPACE );

        // reset the y position
        yPos = yPos + yVect;

        // set the moved flag to indicate success
        moved = true;
       }

    // print the marker at the specified location
    setColor( COLOR_WHITE, COLOR_BLUE, SET_BRIGHT );
    printCharAt( xPos, yPos, PLAYER );

    // return successful move
    return moved;
   }


void screenToMatrix( int screenX, int screenY, short object, short playMatrix[PLAY_AR_W][PLAY_AR_H] )
   {
   // variables

   // convert screen x coordinate to matrix x coordinate

   // convert screen y coordinate to matrix y coordinate

   // store the object in the matrix

   // no return - void
   }


void genObjects( bool xcMode, short gameBoard[ PLAY_AR_W ][ PLAY_AR_H ] )
   {
   // hole generation

   // cloak generation

   // treasure generation

      // extra credit items if extra credit mode is enabled
         // operation: if
              
         // sword generation

         // monster generation

         // spell generation

   // no return - void
   }


void XYPos ( int &xPos, int &yPos )
   {
    // Initalize variables

    // Loop to run until variable = false


    // generate X variable
       // random number between 0 and width of board
	  // Function: rand()

    // generate y variable
       // random number between 0 and height of board
	  // Function: rand()

    // Check if occupied
       // Function: spaceOccupied

    // End loop
       // if spaceOccupied = ture, variable = false

    // no return - void
   }


bool spaceOccupied ( int XPos, int YPos, short playMatrix[PLAY_AR_W][PLAY_AR_H])
   {
    // Initalize Variables
    char object;
    bool response = false;

    // takes XPos and runs it through playMatrix
    object = playMatrix[XPos][YPos];

    // return false if x and y are occupied
       // operation: if
       if( object != SPACE )
         {
          response = true;
         }

    return response;
   }


bool doGenObject( int chancein100 )
   {
    // Initialize Variables
    bool response;
    int number;

    // Get random number between 1 and 100
       // Function get_Random_Number
       number = get_Random_Number(1, 100);       

    // Return true if generated number is less or equal to than input number
       // operation: if
       if( number <= chancein100 )
         {
          response = true;
         }
       else
         {
          response = false;
         }

    return response;
   }


int get_Random_Number(int low_Value, int high_Value)
    {
    // Initialize Variables

    // Initialize Range Value to Inculde Both High & Low Values

    // Generate Random Value Between Low and High; Start at Low Value
       // Function: rand()    

    // return the randomly generated number
    return 0;     // temporary stub return
    }


void gameOverMessage()
   {
   // variables
   int xPos = MESS_UPX + (MESSAGE_W / 2);
   int yPos = NAME_SCR_UPY + 3;

   // clear the message box
      // functions: setColor, clearScreen
      setColor( COLOR_YELLOW, COLOR_RED, SET_BRIGHT );
      clearScreen( MESS_UPX , MESS_UPY, (MESS_UPX + MESSAGE_W), (MESS_UPY + MESSAGE_H) );

   // print message text
      // function: printStringAt
      printStringAt( xPos, yPos, ""GAME"", ""CENTER"");
      xPos = MESS_UPX + (MESSAGE_W / 2);
      yPos += 2;
      printStringAt( xPos, yPos, ""ENDS"", ""CENTER"");

   // wait for user input to terminate game
      // function: waitForInput
      waitForInput( FIXED_WAIT );

   // no return - void
   }


void writeScoreFile( char names[ NAME_LEN ], int scores[], int candidate )
   {
    // initalize variables

    // Open file to sort
       // .open    

    // Sort scores from highest to lowest
       // sortScores

    // Close file
       // .close

   }


void sortScores( char names[ NAME_LEN], int scores[], int candidate)
   {
    // Initilize Variables

    // Takes candidate and bubble sort it through existing scores
    // Places candidate at apropiat index
       // start master loop
       
            // iterate through array and compare values
            
                 // swap values if not in order
          
  }


void showHiScores ( char names[], int scores[] )
   {
    // Initilize Variables

    // Open scoreFile
       // Function .open

    // Set Screen color and clear screen
       // Funtion: setColor, clearScreen

    // Print title
       // Function: printStringAt
   
    // Print ""Names"" & ""Scores"" at certian locations
       // Function: printStringAt

    // Display the name and scores from the file

    // Wait for player to press a button to move back to previous screen
       // function: waitForImput

    // Close File
       // .close

   }
",16292,True,2937.951849435793,median
"---
title: ""FreeBSD 10.1-RELEASE Announcement""
sidenav: download
thisBranch: ""10""
thisRelease: ""10.1""
lastRelease: ""10.0""
thisEOL: ""January 1, 2017""
---

include::share/en/urls.adoc[]

= FreeBSD {{% param thisRelease %}}-RELEASE Announcement

The FreeBSD Release Engineering Team is pleased to announce the availability of FreeBSD {{% param thisRelease %}}-RELEASE. This is the second release of the stable/{{% param thisBranch %}} branch, which improves on the stability of FreeBSD {{% param lastRelease %}}-RELEASE and introduces some new features.

Some of the highlights:

* The new console driver, vt(4), has been added.
* Support for FreeBSD/i386 guests has been added to bhyve(4).
* The bhyve(4) hypervisor now supports booting from a zfs(8) filesystem.
* Support for SMP was added to the `armv6` kernels and enabled by default in the configuration files for all platforms that contain multi-core CPUs.
* Initial support for UEFI boot has been added for the FreeBSD/amd64 architecture.
* Support has been added to cache geli(8) passphrases during system boot.
* Support for the UDP-Lite protocol (RFC 3828) has been added to the IPv4 and IPv6 stacks.
* The new filesystem automount facility, autofs(5), has been added.
* The sshd(8) rc.d(8) startup script now generates ED25519 sshd(8) host keys if keys do not already exist when `ssh_keygen_alg()` is invoked.
* OpenSSH has been updated to version 6.6p1.
* The nc(1) utility has been updated to match the version in OpenBSD 5.5.
* Sendmail has been updated to 8.14.9.
* The unbound(8) caching resolver and ldns have been updated to version 1.4.22.
* OpenPAM has been updated to Ourouparia (20140912).
* OpenSSL has been updated to version 1.0.1j.
* The pkg(8) package management utility has been updated to version 1.3.8.

For a complete list of new features and known problems, please see the online release notes and errata list, available at:

* `https://www.FreeBSD.org/releases/{{% param thisRelease %}}r/relnotes/`
* `https://www.FreeBSD.org/releases/{{% param thisRelease %}}r/errata/`

For more information about FreeBSD release engineering activities, please see:

* `https://www.FreeBSD.org/releng/`

== Availability

FreeBSD {{% param thisRelease %}}-RELEASE is now available for the amd64, i386, ia64, powerpc, powerpc64, sparc64, and armv6 architectures.

FreeBSD {{% param thisRelease %}}-RELEASE can be installed from bootable ISO images or over the network. Some architectures also support installing from a USB memory stick. The required files can be downloaded via FTP as described in the section below. While some of the smaller FTP mirrors may not carry all architectures, they will all generally contain the more common ones such as amd64 and i386.

SHA256 and MD5 hashes for the release ISO and memory stick images are included at the bottom of this message.

A PGP-signed version of this announcement is available at:

* https://www.FreeBSD.org/releases/{{% param thisRelease %}}r/announce.asc

Additional UEFI-capable images are available for the amd64 (x86_64) architecture.

The purpose of the images provided as part of the release are as follows:

*dvd1*: +
This contains everything necessary to install the base FreeBSD operating system, the documentation, and a small set of pre-built packages aimed at getting a graphical workstation up and running. It also supports booting into a ""livefs"" based rescue mode. This should be all you need if you can burn and use DVD-sized media.

*disc1*: +
This contains the base FreeBSD operating system. It also supports booting into a ""livefs"" based rescue mode. There are no pre-built packages.

*bootonly*: +
This supports booting a machine using the CDROM drive but does not contain the installation distribution sets for installing FreeBSD from the CD itself. You would need to perform a network based install (e.g., from an FTP server) after booting from the CD.

*memstick*: +
This can be written to an USB memory stick (flash drive) and used to do an install on machines capable of booting off USB drives. It also supports booting into a ""livefs"" based rescue mode. There are no pre-built packages.

As one example of how to use the memstick image, assuming the USB drive appears as /dev/da0 on your machine something like this should work:

....
# dd if=FreeBSD-{{% param thisRelease %}}-RELEASE-amd64-memstick.img of=/dev/da0 bs=10240 conv=sync
....

Be careful to make sure you get the target (of=) correct.

*mini-memstick*: +
This can be written to an USB memory stick (flash drive) and used to boot a machine, but does not contain the installation distribution sets on the medium itself, similar to the bootonly image. It also supports booting into a ""livefs"" based rescue mode. There are no pre-built packages.

As one example of how to use the mini-memstick image, assuming the USB drive appears as /dev/da0 on your machine something like this should work:

....
# dd if=FreeBSD-{{% param thisRelease %}}-RELEASE-amd64-mini-memstick.img of=/dev/da0 bs=10240 conv=sync
....

Be careful to make sure you get the target (of=) correct.

FreeBSD {{% param thisRelease %}}-RELEASE can also be purchased on CD-ROM or DVD from several vendors. One of the vendors that will be offering FreeBSD {{% param thisRelease %}}-based products is:

* FreeBSD Mall, Inc.` https://www.freebsdmall.com`

Pre-installed virtual machine images are also available for the amd64 (x86_64) and i386 (x86_32) architectures in `QCOW2`, `VHD`, and `VMDK` disk image formats, as well as raw (unformatted) images.

FreeBSD {{% param thisRelease %}}-RELEASE is also available on these cloud hosting platforms:

* Amazon(R) EC2(TM) https://aws.amazon.com/marketplace/pp/B00KSS55FY/[FreeBSD/amd64]
* Microsoft(R) Azure(TM) https://vmdepot.msopentech.com/Vhd/Show?vhdId=49971&version=51112[FreeBSD/amd64], https://vmdepot.msopentech.com/Vhd/Show?vhdId=49972&version=51113[FreeBSD/i386]

== FTP

FreeBSD {{% param thisRelease %}}-RELEASE may be downloaded via ftp from the following site:

* `ftp://ftp.freebsd.org/pub/FreeBSD/releases/ISO-IMAGES/{{% param thisRelease %}}/`

However before trying this site, please check your regional mirror(s) first by going to:

* `ftp://ftp.<your_country_code>.FreeBSD.org/pub/FreeBSD`

Any additional mirror sites will be labeled ftp2, ftp3 and so on.

More information about FreeBSD mirror sites can be found at:

* `link:{handbook}#mirrors-ftp[http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/mirrors-ftp.html]`

FreeBSD {{% param thisRelease %}}-RELEASE virtual machine images may be downloaded via ftp from:

* `ftp://ftp.freebsd.org/pub/FreeBSD/releases/VM-IMAGES/{{% param thisRelease %}}-RELEASE/`

For instructions on installing FreeBSD or updating an existing machine to {{% param thisRelease %}}-RELEASE please see:

* `https://www.FreeBSD.org/releases/{{% param thisRelease %}}r/installation/`

== Support

FreeBSD {{% param thisRelease %}}-RELEASE will be supported until {{% param thisEOL %}}. The End-of-Life dates can be found at:

* `https://www.FreeBSD.org/security/`

== Other Projects Based on FreeBSD

There are many ""third party"" Projects based on FreeBSD. The Projects range from re-packaging FreeBSD into a more ""novice friendly"" distribution to making FreeBSD available on Amazon's EC2 infrastructure. For more information about these Third Party Projects see:

* `https://wiki.FreeBSD.org/3rdPartyProjects`

== Acknowledgments

Many companies donated equipment, network access, or man-hours to support the release engineering activities for FreeBSD {{% param thisRelease %}} including The FreeBSD Foundation, Yahoo!, NetApp, Internet Systems Consortium, ByteMark Hosting, Sentex Communications, New York Internet, Juniper Networks, NLNet Labs, iXsystems, and Yandex.

The release engineering team for {{% param thisRelease %}}-RELEASE includes:

[cols="","",]
|===
|Glen Barber <gjb@FreeBSD.org> |Release Engineering Lead, {{% param thisRelease %}}-RELEASE Release Engineer
|Konstantin Belousov <kib@FreeBSD.org> |Release Engineering
|Joel Dahl <joel@FreeBSD.org> |Release Engineering
|Baptiste Daroussin <bapt@FreeBSD.org> |Package Building
|Bryan Drewery <bdrewery@FreeBSD.org> |Package Building
|Marc Fonvieille <blackend@FreeBSD.org> |Release Engineering, Documentation
|Steven Kreuzer <skreuzer@FreeBSD.org> |Release Engineering
|Xin Li <delphij@FreeBSD.org> |Release Engineering, Security Officer
|Josh Paetzel <jpaetzel@FreeBSD.org> |Release Engineering
|Colin Percival <cperciva@FreeBSD.org> |Security Officer Emeritus
|Craig Rodrigues <rodrigc@FreeBSD.org> |Release Engineering
|Hiroki Sato <hrs@FreeBSD.org> |Release Engineering, Documentation
|Gleb Smirnoff <glebius@FreeBSD.org> |Release Engineering
|Ken Smith <kensmith@FreeBSD.org> |Release Engineering
|Dag-Erling Smørgrav <des@FreeBSD.org> |Security Officer
|Marius Strobl <marius@FreeBSD.org> |Release Engineering
|Robert Watson <rwatson@FreeBSD.org> |Release Engineering, Security
|===

== Trademark

FreeBSD is a registered trademark of The FreeBSD Foundation.

== ISO Image Checksums

=== amd64 (x86_64):

....
SHA256 (FreeBSD-10.1-RELEASE-amd64-bootonly.iso) = 018a36681307ec3e3fe63d7c76ffc4cc53a111c36d9053e43c44856b11547d2a
SHA256 (FreeBSD-10.1-RELEASE-amd64-bootonly.iso.xz) = dacc4b752798b282d4f959b241ae87008f0920125f31933425c057b41a08f0bf
SHA256 (FreeBSD-10.1-RELEASE-amd64-disc1.iso) = 0c3d64ce48c3ef761761d0fea07e1935e296f8c045c249118bc91a7faf053a6b
SHA256 (FreeBSD-10.1-RELEASE-amd64-disc1.iso.xz) = b7249a0b5778225876648214c66d3edfcac3fcf08ecd9dac4a8d87da6678a70c
SHA256 (FreeBSD-10.1-RELEASE-amd64-dvd1.iso) = e643b7beb38fe659c255069c883476b5c9e834c66a969dadded801f10cedba37
SHA256 (FreeBSD-10.1-RELEASE-amd64-dvd1.iso.xz) = d3624c7f01a1f99a641d6a1bdc0672bd27bfbf1ffe68670cc8c940b494a85b5b
SHA256 (FreeBSD-10.1-RELEASE-amd64-memstick.img) = 7a071894f12454442cf24ee4f19c2d21e2a8a79d54c83541d2cb7b9f48497b3e
SHA256 (FreeBSD-10.1-RELEASE-amd64-memstick.img.xz) = 5f44ac7afa902d9258df191916e9e18190cb4321f04e17104caff56026653cc5
SHA256 (FreeBSD-10.1-RELEASE-amd64-mini-memstick.img) = 1be2270ddf487f3129b5fc21955d93cac82905ade4afa3039a87aa60b8236b78
SHA256 (FreeBSD-10.1-RELEASE-amd64-mini-memstick.img.xz) = 91d32e7d3ac31a3eef0217a64ef02eac2b5446bb1dcebb6fd3c94b7bbd28c1f7
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-bootonly.iso) = 4aacf25cd0aec136da6345d01fa35650b9812b0260e0ce8f6845c4c8b4ca377d
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-bootonly.iso.xz) = cd2009d1935e57cb20e993cba013ebc21242878200640bac2332b633302b3c13
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-disc1.iso) = a7f606b448683f975597269b3a69783f80e9bdc74230decf182c48abaac222d0
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-disc1.iso.xz) = 25c07704003ab8ca0f4b4bc5ad4f7693b5dd402d29dcfd0549a8e0bd58e1c6e9
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-dvd1.iso) = 70f039126e430b9f2cc051d38f648eb3c18215c72fe069a67838debe961f6e5e
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-dvd1.iso.xz) = 1ac32ee17120269427386dbd84f40c61ce1924536634136b84ce94da5c51b19d
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-memstick.img) = a1e4072f07bf7e62499f4a13dbe773f1f07c3f8a0071c05acf7b1924e5bec48f
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-memstick.img.xz) = ac5514085b4c4a8c8a6cda992cb9a0b479f4d1ca753cfa3afde45d5ba05b436c
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-mini-memstick.img) = 11b871cc6a20a6dcd69c16152c40242b2175f464495df0b545074535642c4fa9
SHA256 (FreeBSD-10.1-RELEASE-amd64-uefi-mini-memstick.img.xz) = 13b66fa82a91a1a4f1f1826536639f8cd5a41fe29bc5a0c62d2df0e8805cc55b
....

....
MD5 (FreeBSD-10.1-RELEASE-amd64-bootonly.iso) = 7f761efc051e4f48551f1d47217fc964
MD5 (FreeBSD-10.1-RELEASE-amd64-bootonly.iso.xz) = 07cb631f4a62700abe39398a3849743d
MD5 (FreeBSD-10.1-RELEASE-amd64-disc1.iso) = d0d4553080b88653569e1871d57fc819
MD5 (FreeBSD-10.1-RELEASE-amd64-disc1.iso.xz) = 10f0b54d23f523b4084187d5f2c8198f
MD5 (FreeBSD-10.1-RELEASE-amd64-dvd1.iso) = 843e2ac204fcef35fea4950e546a016c
MD5 (FreeBSD-10.1-RELEASE-amd64-dvd1.iso.xz) = f51c6d612e758de517a96cc2c608a5a4
MD5 (FreeBSD-10.1-RELEASE-amd64-memstick.img) = cc904b8f156931d1036c913ec80b192e
MD5 (FreeBSD-10.1-RELEASE-amd64-memstick.img.xz) = 6b96f5d1f8b75580436ab799b241b4bb
MD5 (FreeBSD-10.1-RELEASE-amd64-mini-memstick.img) = b5cda9ffdeea90d4ec3982529279ccd7
MD5 (FreeBSD-10.1-RELEASE-amd64-mini-memstick.img.xz) = 41272f0fde06735bb148504a721d82cf
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-bootonly.iso) = 6d9d98daa1a8395bc4c71939a9365fe2
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-bootonly.iso.xz) = a38f0be1bbd91d076783c94542e78119
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-disc1.iso) = 82fdb43c7b8a77a8119ac5aa7e0ca3fe
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-disc1.iso.xz) = 87e60815eee04e012e7129a4ce6881f5
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-dvd1.iso) = 12a00b38d33d7af0f3833e78f1bcf8b1
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-dvd1.iso.xz) = 8274be64a7a38f4ac6d88ff76d0c8a31
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-memstick.img) = bde386862f0746ee3d12248d29ea4c8f
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-memstick.img.xz) = 1152e3163edd8b91ff0d186c1a246c64
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-mini-memstick.img) = 45c5246064069d95617bff55d07a572b
MD5 (FreeBSD-10.1-RELEASE-amd64-uefi-mini-memstick.img.xz) = 70da2a99275ce4828ebe8158f4e61491
....

=== i386 (x86):

....
SHA256 (FreeBSD-10.1-RELEASE-i386-bootonly.iso) = 215f11d0cd7a6af7be4129f70ba417af4f239ca2f922277b715a7098bdf8ca38
SHA256 (FreeBSD-10.1-RELEASE-i386-bootonly.iso.xz) = 9ea4681d340e9ea3b049d0e3d00601afa74d95dd6ab3fda73611b83d9f029f50
SHA256 (FreeBSD-10.1-RELEASE-i386-disc1.iso) = fe31790b762b01c99791d33e7fd9ab97323654785ce21f588116c8b4eb381cd0
SHA256 (FreeBSD-10.1-RELEASE-i386-disc1.iso.xz) = b765f92da152c00e3a82dceef61e00a0ccd87d004a81c51630a0907cd986ff4f
SHA256 (FreeBSD-10.1-RELEASE-i386-dvd1.iso) = 838f02c547372e8b36b3dbd46169e3cf18464b64f0196e90efdbbeaa3cb49567
SHA256 (FreeBSD-10.1-RELEASE-i386-dvd1.iso.xz) = 231da3aa96ddb90c43aba523dba3d36e445d3b0e8e81c4d9ceaf32e75fd79a26
SHA256 (FreeBSD-10.1-RELEASE-i386-memstick.img) = 583dedeaa95ff76c4384e6589dc882b701a6a40ffdfd4ee2a80ef60092a7d319
SHA256 (FreeBSD-10.1-RELEASE-i386-memstick.img.xz) = 6b304451b026a93e6dc05724043d9ae4036bf8b670f8a3b275fe9983a96e58b8
SHA256 (FreeBSD-10.1-RELEASE-i386-mini-memstick.img) = 20e8692b047000e4e49af0973a0c48b68da198dc1d6ce6c1e0fd134a6d7c8ecd
SHA256 (FreeBSD-10.1-RELEASE-i386-mini-memstick.img.xz) = e44e22fd6b8d69501dd5607337b7b2abf3304c1c7917d923e4a57c067ece607d
....

....
MD5 (FreeBSD-10.1-RELEASE-i386-bootonly.iso) = 369c3dfc8d8bc6161f394953dbe92497
MD5 (FreeBSD-10.1-RELEASE-i386-bootonly.iso.xz) = 93781f084413d19aaeecb0911b458872
MD5 (FreeBSD-10.1-RELEASE-i386-disc1.iso) = 75c7c7ed926e4c01e015a6ea917532ed
MD5 (FreeBSD-10.1-RELEASE-i386-disc1.iso.xz) = a3d223463f7461edfe333b0d6bc3416c
MD5 (FreeBSD-10.1-RELEASE-i386-dvd1.iso) = 55c73545418628e84e3571cc5842b72d
MD5 (FreeBSD-10.1-RELEASE-i386-dvd1.iso.xz) = 14e7a3fe085a74717957aa6ae28d4328
MD5 (FreeBSD-10.1-RELEASE-i386-memstick.img) = 20a8b7a731192f85ab40802ceb2b3927
MD5 (FreeBSD-10.1-RELEASE-i386-memstick.img.xz) = 659f8d731c1eeb766a8048fad1832629
MD5 (FreeBSD-10.1-RELEASE-i386-mini-memstick.img) = 7186991a4c4a7b040e75c1483c94d417
MD5 (FreeBSD-10.1-RELEASE-i386-mini-memstick.img.xz) = c193ff5de9fd91b556ca75f7cf65d316
....

=== ia64:

....
SHA256 (FreeBSD-10.1-RELEASE-ia64-bootonly.iso) = 79ebfa826a412c82c39da4a623e1bc09f846175044ff662b493a313ab8b6ef30
SHA256 (FreeBSD-10.1-RELEASE-ia64-bootonly.iso.xz) = 001fe3f0a7ee8a97c32b6988551ca24386fe893af388cc9ba604141aed84f0be
SHA256 (FreeBSD-10.1-RELEASE-ia64-disc1.iso) = bf5f0d3950d9490522e802acdbce85f28544ccb536029cace73272223a4fc23d
SHA256 (FreeBSD-10.1-RELEASE-ia64-disc1.iso.xz) = 5fbe58dd0b525bd71153db50d7e058ce479c5fb381668ae91c7219bfcb6b3197
SHA256 (FreeBSD-10.1-RELEASE-ia64-memstick.img) = e1e0b8d38dc661e913383e6ceea7b0e424de2219d2e96fbd5069de6a2fad3b29
SHA256 (FreeBSD-10.1-RELEASE-ia64-memstick.img.xz) = 3e68d2ae629814880b6591d6ca00ef5e8f4356dacb4694ed85e5f5d11b545c25
SHA256 (FreeBSD-10.1-RELEASE-ia64-mini-memstick.img) = 05d117e2b5858bba42842b9604efb9462fb2ee7ff58d4449bfd2de89472717ce
SHA256 (FreeBSD-10.1-RELEASE-ia64-mini-memstick.img.xz) = de12e8ea731d6c61339f021bd845618642045eda2a2370231655479c1aa055a8
....

....
MD5 (FreeBSD-10.1-RELEASE-ia64-bootonly.iso) = 2f618152831fa9dfdcefd04c575e176a
MD5 (FreeBSD-10.1-RELEASE-ia64-bootonly.iso.xz) = b6b0a1325e3ba3efbbb7441f9689835c
MD5 (FreeBSD-10.1-RELEASE-ia64-disc1.iso) = 65a64d7c65c888af199038995f794b44
MD5 (FreeBSD-10.1-RELEASE-ia64-disc1.iso.xz) = 501d04715c918f047c9a7694990c68ea
MD5 (FreeBSD-10.1-RELEASE-ia64-memstick.img) = e47a348749e33a26ef16847d358b68e3
MD5 (FreeBSD-10.1-RELEASE-ia64-memstick.img.xz) = 10aa6bc0f233f4bed0631faa934a8944
MD5 (FreeBSD-10.1-RELEASE-ia64-mini-memstick.img) = 7b969e5bcf96bc5657453e3ea6439a30
MD5 (FreeBSD-10.1-RELEASE-ia64-mini-memstick.img.xz) = 634ea43a056ee16c70513cd7a9df4274
....

=== powerpc:

....
SHA256 (FreeBSD-10.1-RELEASE-powerpc-bootonly.iso) = 4bfa59ccbe3503c82ae9a53f3e4f1b9984aa9d1a2c3f62a9554e7b2e7e5f7d5d
SHA256 (FreeBSD-10.1-RELEASE-powerpc-bootonly.iso.xz) = ee15a3a8bcbcb8b74253c8b2098b88df9ab47e6916b6c7a879166ff99e919d73
SHA256 (FreeBSD-10.1-RELEASE-powerpc-disc1.iso) = e28732f2023c839ec4157d01efe65e773a267ea195b451fac0c2ca0222b094c6
SHA256 (FreeBSD-10.1-RELEASE-powerpc-disc1.iso.xz) = 875e7492eb78cb105e6aa421fe14290640627a8dfacdee26a5c1ecd1daa9dec2
SHA256 (FreeBSD-10.1-RELEASE-powerpc-memstick.img) = f011296938b30cc3c8f243a6efa1af0337c92a76b71b3e7788772464b93099d0
SHA256 (FreeBSD-10.1-RELEASE-powerpc-memstick.img.xz) = 2eca4233521a9928222289acfc2e035be8868bd269ebd8b9c72fb4faf2fc32f8
SHA256 (FreeBSD-10.1-RELEASE-powerpc-mini-memstick.img) = e32fdefb9db57699cdc8db6ab6dec9d0100a39dabbc22566710f6defffc2cb49
SHA256 (FreeBSD-10.1-RELEASE-powerpc-mini-memstick.img.xz) = 223657c10c76647431c6baab905bc0f49f77262946c77b8856503a378b2533d8
....

....
MD5 (FreeBSD-10.1-RELEASE-powerpc-bootonly.iso) = 8a96adf66bbe1f78c11315ffb87a9418
MD5 (FreeBSD-10.1-RELEASE-powerpc-bootonly.iso.xz) = 0733497177c62f853019ebfe8addc03a
MD5 (FreeBSD-10.1-RELEASE-powerpc-disc1.iso) = 00e4236a40ebdd816f821024e9b2ff3f
MD5 (FreeBSD-10.1-RELEASE-powerpc-disc1.iso.xz) = 55820da1566f41e551ad81c4772d3b66
MD5 (FreeBSD-10.1-RELEASE-powerpc-memstick.img) = f0d791af2926c39294597382d2b2347b
MD5 (FreeBSD-10.1-RELEASE-powerpc-memstick.img.xz) = 443dde38177f9ea832f7b6fb39413821
MD5 (FreeBSD-10.1-RELEASE-powerpc-mini-memstick.img) = ceb1747602f47230f6f5ce547f542802
MD5 (FreeBSD-10.1-RELEASE-powerpc-mini-memstick.img.xz) = a312731e45fb2215390bf3ad456a465f
....

=== powerpc64:

....
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-bootonly.iso) = 9019c06aa9adc07c1869e2bed9c17a2efd7506e58757dba829df966562d6734f
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-bootonly.iso.xz) = a187a73bfbe4d8a5f8367ef81e1bc12b75ecce765d00a86106b34e0a61b17762
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-disc1.iso) = b3177b929feee1b1b7e1a11e9de1e853530c5463365e7a8e1c0e8f0b8060a711
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-disc1.iso.xz) = 1653cf593867ae097085f26619e47b483621faf9d5e118531f919083a0ac191a
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-memstick.img) = 76b7f8d1db4f52a1220f8c0aae03953adce20729b18711e0810ca4400a42f00d
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-memstick.img.xz) = dc6c6344d226c35ea4bdd299582d66cb2c173eb02d9efc5ea827d5dc9c1f6a46
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-mini-memstick.img) = 3f491270faf03c130ef8a36355c0f3e43d3edbc2b1961172ab286dd0f5326b79
SHA256 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-mini-memstick.img.xz) = 05f4af0621ab829ffc49414951efd6410033f04c1f82cfa3348a0589874e5839
....

....
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-bootonly.iso) = 46edbf7e8206d6790fc0338b157186c6
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-bootonly.iso.xz) = b2e1b21ed727e1e4897b14fc86ecdd3c
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-disc1.iso) = 36bc31330c9bb9ddb2f33a740a34b7e3
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-disc1.iso.xz) = 7596f5a3806bd9c576e912162cd26c49
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-memstick.img) = dfd219d603897dea212fed589fab0bb7
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-memstick.img.xz) = 6c29dbe6a50685ac7fa6195989e17a79
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-mini-memstick.img) = b33e0a4d07a87167a0e761841033169d
MD5 (FreeBSD-10.1-RELEASE-powerpc-powerpc64-mini-memstick.img.xz) = 1d383970297837af1686af41fc0ed3d6
....

=== sparc64:

....
SHA256 (FreeBSD-10.1-RELEASE-sparc64-bootonly.iso) = 1d16052206ddbf934b9335b1f6ac37eebd202d6103690d29b2871cfce24e09b9
SHA256 (FreeBSD-10.1-RELEASE-sparc64-bootonly.iso.xz) = 2eceee7d1169a540953c39f8fff316b488fac9ffdbc7c708a701fc1235d36383
SHA256 (FreeBSD-10.1-RELEASE-sparc64-disc1.iso) = 09fd3898f126446ccd7ab84c1893a0451fe13172cf4e95b0a139f87063d17965
SHA256 (FreeBSD-10.1-RELEASE-sparc64-disc1.iso.xz) = 3b1c060c444e9bb9b8e4dc3e6a7947c74fd4ec7b89f71a1e5cd031109adac613
....

....
MD5 (FreeBSD-10.1-RELEASE-sparc64-bootonly.iso) = ec1487a3b45fbd67516df508354ca7e6
MD5 (FreeBSD-10.1-RELEASE-sparc64-bootonly.iso.xz) = 3cadc6891b453842f110051dd65a0deb
MD5 (FreeBSD-10.1-RELEASE-sparc64-disc1.iso) = 29e14724de8706d6035619e90d1fd275
MD5 (FreeBSD-10.1-RELEASE-sparc64-disc1.iso.xz) = b82a65dfd166e749a343d7c5c7fbe534
....

=== armv6 (BEAGLEBONE):

....
SHA256 (FreeBSD-10.1-RELEASE-arm-armv6-BEAGLEBONE.img.bz2) = 20427b94faee5400acdafd26fa59be284323f3ebef463fdae07102036bafa5c2
....

....
MD5 (FreeBSD-10.1-RELEASE-arm-armv6-BEAGLEBONE.img.bz2) = 92763ed74756af81205577220f655fb7
....

=== armv6 (RPI-B):

....
SHA256 (FreeBSD-10.1-RELEASE-arm-armv6-RPI-B.img.bz2) = 3afd6fb5f9d4bf52c03c3ce26ebef658505a86979c2f7bdedca726b79509c68f
....

....
MD5 (FreeBSD-10.1-RELEASE-arm-armv6-RPI-B.img.bz2) = a9f4130b305a368ec2ceaf1a45e3de31
....

=== armv6 (PANDABOARD):

....
SHA256 (FreeBSD-10.1-RELEASE-arm-armv6-PANDABOARD.img.bz2) = 095d850318c5edb3a89a54313fcfc97b56e9b28e512a46bc3a6c2c47168d0c34
....

....
MD5 (FreeBSD-10.1-RELEASE-arm-armv6-PANDABOARD.img.bz2) = c7f98f10436fbfe53a77d1718113a869
....

=== armv6 (ZEDBOARD):

....
SHA256 (FreeBSD-10.1-RELEASE-arm-armv6-ZEDBOARD.img.bz2) = 664a0da6eb7a97b426510e6b894673604156046c99c2056fa50aaff8fd5c2838
....

....
MD5 (FreeBSD-10.1-RELEASE-arm-armv6-ZEDBOARD.img.bz2) = 1d7046a8eac902b4aaadec2eb80f4739
....

== Virtual Machine Disk Image Checksums

=== amd64 (x86_64):

....
SHA256 (FreeBSD-10.1-RELEASE-amd64.qcow2.xz) = cd7cd17083fc27e61303a4fe958ef7c5d76ff4a5a4dc4e8140f9fcbbe79318aa
SHA256 (FreeBSD-10.1-RELEASE-amd64.raw.xz) = 417dcffa96f011f241d0411c8131ff770055182cd5bfac13a14cf5598f7d1fc9
SHA256 (FreeBSD-10.1-RELEASE-amd64.vhd.xz) = dee50dc8fb4b3fade150bd1c83044752cb924c90f7c956ff028fe96cbb249d89
SHA256 (FreeBSD-10.1-RELEASE-amd64.vmdk.xz) = 62365d4c5cb4c0d2166aa17d3055bd1eb11031197cf0f4a941e82c7052d5bd1a
....

....
MD5 (FreeBSD-10.1-RELEASE-amd64.qcow2.xz) = 4ccd43ada573bfe59ae5f55e90625573
MD5 (FreeBSD-10.1-RELEASE-amd64.raw.xz) = b82d3d653acc2d1793576e12373fc2bc
MD5 (FreeBSD-10.1-RELEASE-amd64.vhd.xz) = 4134062704525d377cc9ed9480830723
MD5 (FreeBSD-10.1-RELEASE-amd64.vmdk.xz) = fd35600f0ed161380f1188f575c5a26a
....

=== i386 (x86):

....
SHA256 (FreeBSD-10.1-RELEASE-i386.qcow2.xz) = 7d41f71f33745edc5c89a97cdc242f5ead847a297b77f2e1c9f5d61519928995
SHA256 (FreeBSD-10.1-RELEASE-i386.raw.xz) = 3391847d935efc885268d398031595ad097eb20dd23ceba0a04d4a975e33d941
SHA256 (FreeBSD-10.1-RELEASE-i386.vhd.xz) = f655fa0b1f3527414770f89dcff7b64bc79ad5269c1a23bc33ca4abea3ab8f7c
SHA256 (FreeBSD-10.1-RELEASE-i386.vmdk.xz) = f18217857d59db0b73962d6b28666c40def1cb7d069b3ce657859486755c0422
....

....
MD5 (FreeBSD-10.1-RELEASE-i386.qcow2.xz) = a0de99d75c5004aae54e32d60485bd05
MD5 (FreeBSD-10.1-RELEASE-i386.raw.xz) = 430af5f70e24652067ad21345651e3ef
MD5 (FreeBSD-10.1-RELEASE-i386.vhd.xz) = eac51224bfcf81bd14c55266b84d39e1
MD5 (FreeBSD-10.1-RELEASE-i386.vmdk.xz) = 8bc11dadbdb10988d40b583a9167f4c7
....

Love FreeBSD? Support this and future releases with a https://www.freebsdfoundation.org/donate/[donation] to The FreeBSD Foundation!
",12180,True,3551.827806458803,median
"/*
 *  Copyright 2019-2022 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 ""GraphicsAccessories.hpp""
#include ""../../../Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h""

#include ""GPUTestingEnvironment.hpp""

#include ""gtest/gtest.h""

using namespace Diligent;
using namespace Diligent::Testing;

extern ""C""
{
    int TestShaderResourceVariableCInterface(void* pVar, void* pObjectToSet);
    int TestShaderResourceBindingCInterface(void* pSRB);
    int TestShaderCInterface(void* pShader);
    int TestPipelineStateCInterface(void* pPSO);
}

namespace Diligent
{

namespace Testing
{

void PrintShaderResources(IShader* pShader)
{
    RefCntAutoPtr<IShaderD3D> pShaderD3D(pShader, IID_ShaderD3D);

    std::stringstream ss;
    ss << ""Resources of shader '"" << pShader->GetDesc().Name << ""':"" << std::endl;
    for (Uint32 res = 0; res < pShader->GetResourceCount(); ++res)
    {
        ShaderResourceDesc ResDec;
        pShader->GetResourceDesc(res, ResDec);

        std::stringstream name_ss;
        name_ss << ResDec.Name;
        if (ResDec.ArraySize > 1)
            name_ss << ""["" << ResDec.ArraySize << ""]"";
        ss << std::setw(2) << std::right << res << "": "" << std::setw(25) << std::left << name_ss.str();
        if (pShaderD3D)
        {
            HLSLShaderResourceDesc HLSLResDesc;
            pShaderD3D->GetHLSLResource(res, HLSLResDesc);
            ss << ""  hlsl register "" << std::setw(2) << HLSLResDesc.ShaderRegister;
        }
        ss << ""   "" << GetShaderResourceTypeLiteralName(ResDec.Type) << std::endl;
    }
    LOG_INFO_MESSAGE(ss.str());
}

} // namespace Testing

} // namespace Diligent
namespace
{

TEST(ShaderResourceLayout, VariableAccess)
{
    auto* pEnv     = GPUTestingEnvironment::GetInstance();
    auto* pDevice  = pEnv->GetDevice();
    auto* pContext = pEnv->GetDeviceContext();

    const auto& DeviceInfo = pDevice->GetDeviceInfo();
    if (!DeviceInfo.Features.SeparablePrograms)
    {
        GTEST_SKIP() << ""Shader variable access test requires separate programs"";
    }

    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;

    ShaderCreateInfo ShaderCI;

    RefCntAutoPtr<IShaderSourceInputStreamFactory> pShaderSourceFactory;
    pDevice->GetEngineFactory()->CreateDefaultShaderSourceStreamFactory(""shaders"", &pShaderSourceFactory);
    ShaderCI.pShaderSourceStreamFactory = pShaderSourceFactory;
    ShaderCI.EntryPoint                 = ""main"";
    ShaderCI.UseCombinedTextureSamplers = true;

    RefCntAutoPtr<ISampler> pSamplers[2];
    IDeviceObject*          pSams[2] = {};
    for (size_t i = 0; i < _countof(pSams); ++i)
    {
        SamplerDesc SamDesc;
        pDevice->CreateSampler(SamDesc, &(pSamplers[i]));
        pSams[i] = pSamplers[i];
    }

    RefCntAutoPtr<ITexture> pTex[2];
    TextureDesc             TexDesc;
    TexDesc.Type            = RESOURCE_DIM_TEX_2D;
    TexDesc.Width           = 1024;
    TexDesc.Height          = 1024;
    TexDesc.Format          = TEX_FORMAT_RGBA8_UNORM_SRGB;
    TexDesc.BindFlags       = BIND_SHADER_RESOURCE;
    IDeviceObject* pSRVs[2] = {};
    for (size_t i = 0; i < _countof(pSRVs); ++i)
    {
        pDevice->CreateTexture(TexDesc, nullptr, &(pTex[i]));
        auto* pSRV = pTex[i]->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
        pSRV->SetSampler(pSamplers[i]);
        pSRVs[i] = pSRV;
    }

    RefCntAutoPtr<ITexture> pRWTex[8];
    IDeviceObject*          pTexUAVs[_countof(pRWTex)]   = {};
    IDeviceObject*          pRWTexSRVs[_countof(pRWTex)] = {};
    TexDesc.BindFlags                                    = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
    TexDesc.Format                                       = TEX_FORMAT_RGBA32_FLOAT;
    for (size_t i = 0; i < _countof(pRWTex); ++i)
    {
        pDevice->CreateTexture(TexDesc, nullptr, &(pRWTex[i]));
        pTexUAVs[i]   = pRWTex[i]->GetDefaultView(TEXTURE_VIEW_UNORDERED_ACCESS);
        pRWTexSRVs[i] = pRWTex[i]->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
    }


    //RefCntAutoPtr<ITexture> pStorageTex[4];
    //IDeviceObject *pUAVs[4];
    //for (int i = 0; i < 4; ++i)
    //{
    //    pDevice->CreateTexture(TexDesc, TextureData{}, &(pStorageTex[i]));
    //    pUAVs[i] = pStorageTex[i]->GetDefaultView(TEXTURE_VIEW_UNORDERED_ACCESS);
    //}

    constexpr auto RTVFormat = TEX_FORMAT_RGBA8_UNORM;
    constexpr auto DSVFormat = TEX_FORMAT_D32_FLOAT;

    TexDesc.Format    = RTVFormat;
    TexDesc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
    RefCntAutoPtr<ITexture> pRenderTarget;
    pDevice->CreateTexture(TexDesc, nullptr, &pRenderTarget);
    auto* pRTV = pRenderTarget->GetDefaultView(TEXTURE_VIEW_RENDER_TARGET);

    TexDesc.Format    = DSVFormat;
    TexDesc.BindFlags = BIND_DEPTH_STENCIL;
    RefCntAutoPtr<ITexture> pDepthTex;
    pDevice->CreateTexture(TexDesc, nullptr, &pDepthTex);
    auto* pDSV = pDepthTex->GetDefaultView(TEXTURE_VIEW_DEPTH_STENCIL);

    BufferDesc BuffDesc;
    BuffDesc.Size      = 1024;
    BuffDesc.BindFlags = BIND_UNIFORM_BUFFER;
    RefCntAutoPtr<IBuffer> pUniformBuffs[2];
    IDeviceObject*         pUBs[2];
    for (size_t i = 0; i < _countof(pUniformBuffs); ++i)
    {
        pDevice->CreateBuffer(BuffDesc, nullptr, &(pUniformBuffs[i]));
        pUBs[i] = pUniformBuffs[i];
    }

    //BuffDesc.BindFlags = BIND_UNORDERED_ACCESS;
    //BuffDesc.Mode = BUFFER_MODE_STRUCTURED;
    //BuffDesc.ElementByteStride = 16;
    //RefCntAutoPtr<IBuffer> pStorgeBuffs[4];
    //IDeviceObject *pSBUAVs[4];
    //for (int i = 0; i < 4; ++i)
    //{
    //    pDevice->CreateBuffer(BuffDesc, BufferData{}, &(pStorgeBuffs[i]));
    //    pSBUAVs[i] = pStorgeBuffs[i]->GetDefaultView(BUFFER_VIEW_UNORDERED_ACCESS);
    //}

    RefCntAutoPtr<IBuffer>     pFormattedBuff0, pFormattedBuff[4], pRawBuff[2];
    IDeviceObject *            pFormattedBuffSRV = nullptr, *pFormattedBuffUAV[4] = {}, *pFormattedBuffSRVs[4] = {};
    RefCntAutoPtr<IBufferView> spFormattedBuffSRV, spFormattedBuffUAV[4], spFormattedBuffSRVs[4];
    RefCntAutoPtr<IBufferView> spRawBuffUAV[2], spRawBuffSRVs[2];
    {
        BufferDesc TxlBuffDesc;
        TxlBuffDesc.Name              = ""Uniform texel buffer test"";
        TxlBuffDesc.Size              = 256;
        TxlBuffDesc.BindFlags         = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
        TxlBuffDesc.Usage             = USAGE_DEFAULT;
        TxlBuffDesc.ElementByteStride = 16;
        TxlBuffDesc.Mode              = BUFFER_MODE_FORMATTED;
        pDevice->CreateBuffer(TxlBuffDesc, nullptr, &pFormattedBuff0);

        BufferViewDesc ViewDesc;
        ViewDesc.ViewType             = BUFFER_VIEW_SHADER_RESOURCE;
        ViewDesc.Format.ValueType     = VT_FLOAT32;
        ViewDesc.Format.NumComponents = 4;
        ViewDesc.Format.IsNormalized  = false;
        pFormattedBuff0->CreateView(ViewDesc, &spFormattedBuffSRV);
        pFormattedBuffSRV = spFormattedBuffSRV;

        for (size_t i = 0; i < _countof(pFormattedBuff); ++i)
        {
            TxlBuffDesc.Name      = ""UAV buffer test"";
            TxlBuffDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
            pDevice->CreateBuffer(TxlBuffDesc, nullptr, &(pFormattedBuff[i]));

            ViewDesc.ViewType = BUFFER_VIEW_UNORDERED_ACCESS;
            pFormattedBuff[i]->CreateView(ViewDesc, &(spFormattedBuffUAV[i]));
            pFormattedBuffUAV[i] = spFormattedBuffUAV[i];

            ViewDesc.ViewType = BUFFER_VIEW_SHADER_RESOURCE;
            pFormattedBuff[i]->CreateView(ViewDesc, &(spFormattedBuffSRVs[i]));
            pFormattedBuffSRVs[i] = spFormattedBuffSRVs[i];
        }

        TxlBuffDesc.Mode          = BUFFER_MODE_RAW;
        ViewDesc.Format.ValueType = VT_UNDEFINED;
        for (size_t i = 0; i < _countof(pRawBuff); ++i)
        {
            TxlBuffDesc.Name = ""Raw buffer test"";
            pDevice->CreateBuffer(TxlBuffDesc, nullptr, &(pRawBuff[i]));
            spRawBuffUAV[i]  = pRawBuff[i]->GetDefaultView(BUFFER_VIEW_UNORDERED_ACCESS);
            spRawBuffSRVs[i] = pRawBuff[i]->GetDefaultView(BUFFER_VIEW_SHADER_RESOURCE);
        }
    }

    RefCntAutoPtr<IShader> pVS;
    {
        ShaderCI.Desc.Name       = ""Shader variable access test VS"";
        ShaderCI.Desc.ShaderType = SHADER_TYPE_VERTEX;
        if (DeviceInfo.IsD3DDevice())
        {
            ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;
            ShaderCI.FilePath       = ""ShaderVariableAccessTestDX.vsh"";
        }
        else
        {
            ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_GLSL;
            ShaderCI.FilePath       = ""ShaderVariableAccessTestGL.vsh"";
        }
        ShaderCI.ShaderCompiler = pEnv->GetDefaultCompiler(ShaderCI.SourceLanguage);

        pDevice->CreateShader(ShaderCI, &pVS);
        ASSERT_NE(pVS, nullptr);
        TestShaderCInterface(pVS);

        if (!DeviceInfo.IsMetalDevice())
        {
            // Resource queries from shader are not supported in Metal
            Diligent::Testing::PrintShaderResources(pVS);
        }
    }

    // clang-format off
    std::vector<ShaderResourceVariableDesc> VarDesc =
        {
            {SHADER_TYPE_VERTEX, ""g_tex2D_Static"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            {SHADER_TYPE_PIXEL,  ""g_tex2D_Static"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},

            {SHADER_TYPE_VERTEX, ""g_tex2D_StaticArr"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            {SHADER_TYPE_PIXEL,  ""g_tex2D_StaticArr"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},

            {SHADER_TYPE_VERTEX, ""g_tex2D_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL,  ""g_tex2D_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},

            {SHADER_TYPE_VERTEX, ""g_tex2D_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
            {SHADER_TYPE_PIXEL,  ""g_tex2D_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},

            {SHADER_TYPE_VERTEX, ""g_tex2D_MutArr"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL,  ""g_tex2D_MutArr"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},

            {SHADER_TYPE_VERTEX, ""g_tex2D_DynArr"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
            {SHADER_TYPE_PIXEL,  ""g_tex2D_DynArr"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},

            {SHADER_TYPE_VERTEX, ""UniformBuff_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL,  ""UniformBuff_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},

            {SHADER_TYPE_VERTEX, ""UniformBuff_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
            {SHADER_TYPE_PIXEL,  ""UniformBuff_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},

            {SHADER_TYPE_VERTEX, ""g_Buffer_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL,  ""g_Buffer_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},

            {SHADER_TYPE_VERTEX, ""g_Buffer_MutArr"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL,  ""g_Buffer_MutArr"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},

            {SHADER_TYPE_VERTEX, ""g_Buffer_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
            {SHADER_TYPE_PIXEL,  ""g_Buffer_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},

            {SHADER_TYPE_VERTEX, ""g_Buffer_DynArr"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
            {SHADER_TYPE_PIXEL,  ""g_Buffer_DynArr"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},

            {SHADER_TYPE_PIXEL, ""g_rwtex2D_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL, ""g_rwtex2D_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
            {SHADER_TYPE_PIXEL, ""g_rwBuff_Mut"", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
            {SHADER_TYPE_PIXEL, ""g_rwBuff_Dyn"", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC},
        };
    // clang-format on

    ImmutableSamplerDesc ImtblSamplers[] =
        {
            {SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_tex2D_Static"", SamplerDesc{}},
            {SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_tex2D_StaticArr"", SamplerDesc{}},
            {SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_tex2D_Mut"", SamplerDesc{}},
            {SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_tex2D_MutArr"", SamplerDesc{}},
            {SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_tex2D_Dyn"", SamplerDesc{}},
            {SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_tex2D_DynArr"", SamplerDesc{}},
        };

    RefCntAutoPtr<IShader> pPS;
    {
        ShaderCI.Desc.Name       = ""Shader variable access test PS"";
        ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
        if (DeviceInfo.IsD3DDevice())
        {
            ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;
            ShaderCI.FilePath       = ""ShaderVariableAccessTestDX.psh"";
        }
        else
        {
            ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_GLSL;
            ShaderCI.FilePath       = ""ShaderVariableAccessTestGL.psh"";
        }
        ShaderCI.ShaderCompiler = pEnv->GetDefaultCompiler(ShaderCI.SourceLanguage);
        pDevice->CreateShader(ShaderCI, &pPS);
        ASSERT_NE(pPS, nullptr);

        if (!DeviceInfo.IsMetalDevice())
        {
            // Resource queries from shader are not supported in Metal
            Diligent::Testing::PrintShaderResources(pPS);
        }
    }


    GraphicsPipelineStateCreateInfo PSOCreateInfo;

    auto& PSODesc          = PSOCreateInfo.PSODesc;
    auto& ResourceLayout   = PSODesc.ResourceLayout;
    auto& GraphicsPipeline = PSOCreateInfo.GraphicsPipeline;

    ResourceLayout.Variables            = VarDesc.data();
    ResourceLayout.NumVariables         = static_cast<Uint32>(VarDesc.size());
    ResourceLayout.NumImmutableSamplers = _countof(ImtblSamplers);
    ResourceLayout.ImmutableSamplers    = ImtblSamplers;

    PSODesc.Name                       = ""Shader variable access test PSO"";
    PSOCreateInfo.pVS                  = pVS;
    PSOCreateInfo.pPS                  = pPS;
    GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    GraphicsPipeline.NumRenderTargets  = 1;
    GraphicsPipeline.RTVFormats[0]     = RTVFormat;
    GraphicsPipeline.DSVFormat         = DSVFormat;
    PSODesc.SRBAllocationGranularity   = 16;

    RefCntAutoPtr<IPipelineState> pTestPSO;
    pDevice->CreateGraphicsPipelineState(PSOCreateInfo, &pTestPSO);
    ASSERT_NE(pTestPSO, nullptr);
    EXPECT_EQ(TestPipelineStateCInterface(pTestPSO), 0);

    LOG_INFO_MESSAGE(""No worries, warnings below are expected - testing variable queries from inactive/invalid shader stages\\n"");

    EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_GEOMETRY), 0u);
    EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_DOMAIN), 0u);
    EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_HULL), 0u);
    EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_COMPUTE), 0u);
    EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_AMPLIFICATION), 0u);
    EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_MESH), 0u);

    EXPECT_EQ(pTestPSO->GetStaticVariableByName(SHADER_TYPE_GEOMETRY, ""g_tex2D_Static""), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByName(SHADER_TYPE_DOMAIN, ""g_tex2D_Static""), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByName(SHADER_TYPE_HULL, ""g_tex2D_Static""), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByName(SHADER_TYPE_COMPUTE, ""g_tex2D_Static""), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByName(SHADER_TYPE_AMPLIFICATION, ""g_tex2D_Static""), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByName(SHADER_TYPE_MESH, ""g_tex2D_Static""), nullptr);

    EXPECT_EQ(pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_GEOMETRY, 0), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_DOMAIN, 0), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_HULL, 0), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_COMPUTE, 0), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_AMPLIFICATION, 0), nullptr);
    EXPECT_EQ(pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_MESH, 0), nullptr);

    {
        EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_VERTEX), 6u);

        {
            auto tex2D_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Static"");
            ASSERT_NE(tex2D_Static, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_Static->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(tex2D_Static, pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            tex2D_Static->Set(pSRVs[0]);
            EXPECT_EQ(tex2D_Static->Get(), pSRVs[0]);

            tex2D_Static->Set(pSRVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Static->Get(), pSRVs[1]);
            tex2D_Static->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Static->Get(), nullptr);

            tex2D_Static->Set(pSRVs[0]);
            EXPECT_EQ(tex2D_Static->Get(), pSRVs[0]);
        }

        {
            auto tex2D_Static_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Static_sampler"");
            EXPECT_EQ(tex2D_Static_sampler, nullptr);
        }

        {
            auto tex2D_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_StaticArr"");
            ASSERT_NE(tex2D_StaticArr, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_StaticArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(tex2D_StaticArr, pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            tex2D_StaticArr->SetArray(pSRVs, 0, 2);
            EXPECT_EQ(tex2D_StaticArr->Get(0), pSRVs[0]);
            EXPECT_EQ(tex2D_StaticArr->Get(1), pSRVs[1]);

            tex2D_StaticArr->SetArray(pSRVs + 1, 0, 1, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_StaticArr->Get(0), pSRVs[1]);
            tex2D_StaticArr->SetArray(pSRVs, 0, 1, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_StaticArr->Get(0), pSRVs[0]);
        }

        {
            auto tex2D_StaticArr_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_StaticArr_sampler"");
            EXPECT_EQ(tex2D_StaticArr_sampler, nullptr);
        }

        {
            auto UniformBuff_Stat = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""UniformBuff_Stat"");
            ASSERT_NE(UniformBuff_Stat, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Stat->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Stat, pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            UniformBuff_Stat->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Stat->Get(), pUBs[0]);

            UniformBuff_Stat->Set(pUBs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Stat->Get(), pUBs[1]);
            UniformBuff_Stat->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Stat->Get(), nullptr);

            UniformBuff_Stat->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Stat->Get(), pUBs[0]);
        }

        {
            auto UniformBuff_Stat2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""UniformBuff_Stat2"");
            ASSERT_NE(UniformBuff_Stat2, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Stat2->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Stat2, pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            UniformBuff_Stat2->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Stat2->Get(), pUBs[0]);
        }

        {
            auto Buffer_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_Buffer_Static"");
            ASSERT_NE(Buffer_Static, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_Static->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(Buffer_Static, pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            Buffer_Static->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Static->Get(), pFormattedBuffSRV);

            Buffer_Static->Set(pFormattedBuffSRVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(Buffer_Static->Get(), pFormattedBuffSRVs[1]);
            Buffer_Static->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(Buffer_Static->Get(), nullptr);

            Buffer_Static->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Static->Get(), pFormattedBuffSRV);
        }

        {
            auto Buffer_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_Buffer_StaticArr"");
            ASSERT_NE(Buffer_StaticArr, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_StaticArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(Buffer_StaticArr, pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            Buffer_StaticArr->SetArray(&pFormattedBuffSRV, 0, 1);
            Buffer_StaticArr->SetArray(&pFormattedBuffSRV, 1, 1);
            EXPECT_EQ(Buffer_StaticArr->Get(0), pFormattedBuffSRV);
            EXPECT_EQ(Buffer_StaticArr->Get(1), pFormattedBuffSRV);
        }


        {
            auto tex2D_Mut = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Mut"");
            EXPECT_EQ(tex2D_Mut, nullptr);
        }
        {
            auto tex2D_Dyn = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Dyn"");
            EXPECT_EQ(tex2D_Dyn, nullptr);
        }
        {
            auto tex2D_Mut_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Mut_sampler"");
            EXPECT_EQ(tex2D_Mut_sampler, nullptr);
        }
        {
            auto tex2D_Dyn_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_DynArr_sampler"");
            EXPECT_EQ(tex2D_Dyn_sampler, nullptr);
        }



        auto NumVSVars = pTestPSO->GetStaticVariableCount(SHADER_TYPE_VERTEX);
        for (Uint32 v = 0; v < NumVSVars; ++v)
        {
            auto pVar = pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_VERTEX, v);
            EXPECT_EQ(pVar->GetIndex(), v);
            EXPECT_EQ(pVar->GetType(), SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
            ShaderResourceDesc ResDesc;
            pVar->GetResourceDesc(ResDesc);
            auto pVar2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name);
            EXPECT_EQ(pVar, pVar2);
        }
    }


    {
        EXPECT_EQ(pTestPSO->GetStaticVariableCount(SHADER_TYPE_PIXEL), 9u);

        {
            auto tex2D_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Static"");
            ASSERT_NE(tex2D_Static, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_Static->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(tex2D_Static, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            tex2D_Static->Set(pSRVs[0]);
            EXPECT_EQ(tex2D_Static->Get(), pSRVs[0]);

            tex2D_Static->Set(pSRVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Static->Get(), pSRVs[1]);
            tex2D_Static->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Static->Get(), nullptr);

            tex2D_Static->Set(pSRVs[0]);
            EXPECT_EQ(tex2D_Static->Get(), pSRVs[0]);
        }

        {
            auto tex2D_Static_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Static_sampler"");
            EXPECT_EQ(tex2D_Static_sampler, nullptr);
        }

        {
            auto tex2D_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_StaticArr"");
            ASSERT_NE(tex2D_StaticArr, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_StaticArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(tex2D_StaticArr, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            tex2D_StaticArr->SetArray(pSRVs, 0, 2);
            EXPECT_EQ(tex2D_StaticArr->Get(0), pSRVs[0]);
            EXPECT_EQ(tex2D_StaticArr->Get(1), pSRVs[1]);
        }
        {
            auto tex2D_StaticArr_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_StaticArr_sampler"");
            EXPECT_EQ(tex2D_StaticArr_sampler, nullptr);
        }

        {
            auto UniformBuff_Stat = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""UniformBuff_Stat"");
            ASSERT_NE(UniformBuff_Stat, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Stat->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Stat, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            UniformBuff_Stat->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Stat->Get(), pUBs[0]);

            UniformBuff_Stat->Set(pUBs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Stat->Get(), pUBs[1]);
            UniformBuff_Stat->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Stat->Get(), nullptr);

            UniformBuff_Stat->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Stat->Get(), pUBs[0]);
        }

        {
            auto UniformBuff_Stat2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""UniformBuff_Stat2"");
            ASSERT_NE(UniformBuff_Stat2, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Stat2->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Stat2, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            UniformBuff_Stat2->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Stat2->Get(), pUBs[0]);
        }

        {
            auto Buffer_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_Static"");
            ASSERT_NE(Buffer_Static, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_Static->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(Buffer_Static, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            Buffer_Static->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Static->Get(), pFormattedBuffSRV);
        }

        {
            auto Buffer_StaticArr = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_StaticArr"");
            ASSERT_NE(Buffer_StaticArr, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_StaticArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(Buffer_StaticArr, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            Buffer_StaticArr->SetArray(&pFormattedBuffSRV, 0, 1);
            Buffer_StaticArr->SetArray(&pFormattedBuffSRV, 1, 1);
            EXPECT_EQ(Buffer_StaticArr->Get(0), pFormattedBuffSRV);
            EXPECT_EQ(Buffer_StaticArr->Get(1), pFormattedBuffSRV);
        }


        {
            auto rwtex2D_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_rwtex2D_Static"");
            ASSERT_NE(rwtex2D_Static, nullptr);
            ShaderResourceDesc ResDesc;
            rwtex2D_Static->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwtex2D_Static, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwtex2D_Static->Set(pTexUAVs[0]);
            EXPECT_EQ(rwtex2D_Static->Get(), pTexUAVs[0]);

            rwtex2D_Static->Set(pTexUAVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwtex2D_Static->Get(), pTexUAVs[1]);
            rwtex2D_Static->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwtex2D_Static->Get(), nullptr);

            rwtex2D_Static->Set(pTexUAVs[0]);
            EXPECT_EQ(rwtex2D_Static->Get(), pTexUAVs[0]);
        }


        {
            auto rwtex2D_Static2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_rwtex2D_Static2"");
            ASSERT_NE(rwtex2D_Static2, nullptr);
            ShaderResourceDesc ResDesc;
            rwtex2D_Static2->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwtex2D_Static2, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwtex2D_Static2->Set(pTexUAVs[1]);
            EXPECT_EQ(rwtex2D_Static2->Get(), pTexUAVs[1]);
        }

        {
            auto rwBuff_Static = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_rwBuff_Static"");
            ASSERT_NE(rwBuff_Static, nullptr);
            ShaderResourceDesc ResDesc;
            rwBuff_Static->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwBuff_Static, pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwBuff_Static->Set(spRawBuffUAV[0]);
            EXPECT_EQ(rwBuff_Static->Get(), spRawBuffUAV[0].RawPtr());

            rwBuff_Static->Set(spRawBuffUAV[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwBuff_Static->Get(), spRawBuffUAV[1].RawPtr());
            rwBuff_Static->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwBuff_Static->Get(), nullptr);

            rwBuff_Static->Set(spRawBuffUAV[0]);
            EXPECT_EQ(rwBuff_Static->Get(), spRawBuffUAV[0].RawPtr());
        }


        {
            auto tex2D_Mut = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Mut"");
            EXPECT_EQ(tex2D_Mut, nullptr);
        }
        {
            auto tex2D_Dyn = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Dyn"");
            EXPECT_EQ(tex2D_Dyn, nullptr);
        }
        {
            auto tex2D_Mut_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Mut_sampler"");
            EXPECT_EQ(tex2D_Mut_sampler, nullptr);
        }
        {
            auto tex2D_Dyn_sampler = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_DynArr_sampler"");
            EXPECT_EQ(tex2D_Dyn_sampler, nullptr);
        }


        auto NumPSVars = pTestPSO->GetStaticVariableCount(SHADER_TYPE_PIXEL);
        for (Uint32 v = 0; v < NumPSVars; ++v)
        {
            auto pVar = pTestPSO->GetStaticVariableByIndex(SHADER_TYPE_PIXEL, v);
            EXPECT_EQ(pVar->GetIndex(), v);
            EXPECT_EQ(pVar->GetType(), SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
            ShaderResourceDesc ResDesc;
            pVar->GetResourceDesc(ResDesc);
            auto pVar2 = pTestPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name);
            EXPECT_EQ(pVar, pVar2);
        }
    }

    RefCntAutoPtr<IShaderResourceBinding> pSRB;
    pTestPSO->CreateShaderResourceBinding(&pSRB, false);
    ASSERT_NE(pSRB, nullptr);
    EXPECT_EQ(TestShaderResourceBindingCInterface(pSRB.RawPtr()), 0);

    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_GEOMETRY), 0u);
    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_HULL), 0u);
    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_DOMAIN), 0u);
    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_COMPUTE), 0u);
    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_AMPLIFICATION), 0u);
    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_MESH), 0u);

    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_GEOMETRY, ""g_tex2D_Mut""), nullptr);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_HULL, ""g_tex2D_Mut""), nullptr);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_DOMAIN, ""g_tex2D_Mut""), nullptr);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_COMPUTE, ""g_tex2D_Mut""), nullptr);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_AMPLIFICATION, ""g_tex2D_Mut""), nullptr);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_MESH, ""g_tex2D_Mut""), nullptr);

    EXPECT_EQ(pSRB->GetVariableByIndex(SHADER_TYPE_GEOMETRY, 0), nullptr);
    EXPECT_EQ(pSRB->GetVariableByIndex(SHADER_TYPE_HULL, 0), nullptr);
    EXPECT_EQ(pSRB->GetVariableByIndex(SHADER_TYPE_DOMAIN, 0), nullptr);
    EXPECT_EQ(pSRB->GetVariableByIndex(SHADER_TYPE_COMPUTE, 0), nullptr);
    EXPECT_EQ(pSRB->GetVariableByIndex(SHADER_TYPE_AMPLIFICATION, 0), nullptr);
    EXPECT_EQ(pSRB->GetVariableByIndex(SHADER_TYPE_MESH, 0), nullptr);

    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_MUT_DYN);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_UPDATE_STATIC | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_NONE);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_UPDATE_MUTABLE | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_MUTABLE);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_UPDATE_DYNAMIC | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_DYNAMIC);

    {
        {
            auto tex2D_Mut = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Mut"");
            ASSERT_NE(tex2D_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(tex2D_Mut, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            tex2D_Mut->Set(pSRVs[0]);
            EXPECT_EQ(tex2D_Mut->Get(), pSRVs[0]);

            tex2D_Mut->Set(pSRVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Mut->Get(), pSRVs[1]);
            tex2D_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Mut->Get(), nullptr);

            tex2D_Mut->Set(pSRVs[0]);
            EXPECT_EQ(tex2D_Mut->Get(), pSRVs[0]);
        }

        {
            auto tex2D_Mut_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Mut_sampler"");
            EXPECT_EQ(tex2D_Mut_sampler, nullptr);
        }

        {
            auto tex2D_MutArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_MutArr"");
            ASSERT_NE(tex2D_MutArr, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_MutArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(tex2D_MutArr, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            tex2D_MutArr->SetArray(pSRVs, 0, 2);
            EXPECT_EQ(tex2D_MutArr->Get(0), pSRVs[0]);
            EXPECT_EQ(tex2D_MutArr->Get(1), pSRVs[1]);
        }

        {
            auto tex2D_MutArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_MutArr_sampler"");
            EXPECT_EQ(tex2D_MutArr_sampler, nullptr);
        }

        {
            auto tex2D_Dyn = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Dyn"");
            ASSERT_NE(tex2D_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(tex2D_Dyn, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            //tex2D_Dyn->Set(pSRVs[0]);
            EXPECT_EQ(TestShaderResourceVariableCInterface(tex2D_Dyn, pSRVs[0]), 0);
        }

        {
            auto tex2D_Dyn_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Dyn_sampler"");
            EXPECT_EQ(tex2D_Dyn_sampler, nullptr);
        }

        {
            auto tex2D_DynArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_DynArr"");
            ASSERT_NE(tex2D_DynArr, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_DynArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(tex2D_DynArr, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            tex2D_DynArr->SetArray(pSRVs, 0, 2);
            EXPECT_EQ(tex2D_DynArr->Get(0), pSRVs[0]);
            EXPECT_EQ(tex2D_DynArr->Get(1), pSRVs[1]);
        }

        {
            auto tex2D_DynArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_DynArr_sampler"");
            EXPECT_EQ(tex2D_DynArr_sampler, nullptr);
        }

        {
            auto UniformBuff_Mut = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""UniformBuff_Mut"");
            ASSERT_NE(UniformBuff_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Mut, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            UniformBuff_Mut->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Mut->Get(), pUBs[0]);

            UniformBuff_Mut->Set(pUBs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Mut->Get(), pUBs[1]);
            UniformBuff_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Mut->Get(), nullptr);

            UniformBuff_Mut->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Mut->Get(), pUBs[0]);
        }

        {
            auto UniformBuff_Dyn = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""UniformBuff_Dyn"");
            ASSERT_NE(UniformBuff_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Dyn, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            UniformBuff_Dyn->Set(pUBs[1]);
            EXPECT_EQ(UniformBuff_Dyn->Get(0), pUBs[1]);
            UniformBuff_Dyn->Set(nullptr);
            EXPECT_EQ(UniformBuff_Dyn->Get(0), nullptr);
            UniformBuff_Dyn->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Dyn->Get(0), pUBs[0]);
        }

        {
            auto Buffer_Mut = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_Buffer_Mut"");
            ASSERT_NE(Buffer_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(Buffer_Mut, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            Buffer_Mut->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Mut->Get(0), pFormattedBuffSRV);

            Buffer_Mut->Set(pFormattedBuffSRVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(Buffer_Mut->Get(0), pFormattedBuffSRVs[1]);
            Buffer_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(Buffer_Mut->Get(0), nullptr);

            Buffer_Mut->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Mut->Get(0), pFormattedBuffSRV);
        }

        {
            auto Buffer_MutArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_Buffer_MutArr"");
            ASSERT_NE(Buffer_MutArr, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_MutArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(Buffer_MutArr, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            Buffer_MutArr->SetArray(&pFormattedBuffSRV, 0, 1);
            Buffer_MutArr->SetArray(&pFormattedBuffSRV, 1, 1);
            EXPECT_EQ(Buffer_MutArr->Get(0), pFormattedBuffSRV);
            EXPECT_EQ(Buffer_MutArr->Get(1), pFormattedBuffSRV);
        }

        {
            auto Buffer_Dyn = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_Buffer_Dyn"");
            ASSERT_NE(Buffer_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(Buffer_Dyn, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            Buffer_Dyn->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Dyn->Get(0), pFormattedBuffSRV);
            Buffer_Dyn->Set(nullptr);
            EXPECT_EQ(Buffer_Dyn->Get(0), nullptr);
            Buffer_Dyn->Set(pFormattedBuffSRV);
            EXPECT_EQ(Buffer_Dyn->Get(0), pFormattedBuffSRV);
        }

        {
            auto Buffer_DynArr = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_Buffer_DynArr"");
            ASSERT_NE(Buffer_DynArr, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_DynArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(Buffer_DynArr, pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name));
            Buffer_DynArr->SetArray(&pFormattedBuffSRV, 0, 1);
            Buffer_DynArr->SetArray(&pFormattedBuffSRV, 1, 1);
            EXPECT_EQ(Buffer_DynArr->Get(0), pFormattedBuffSRV);
            EXPECT_EQ(Buffer_DynArr->Get(1), pFormattedBuffSRV);
        }

        {
            auto tex2D_Static = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""g_tex2D_Static"");
            EXPECT_EQ(tex2D_Static, nullptr);
        }

        auto UniformBuff_Stat = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""UniformBuff_Stat"");
        EXPECT_EQ(UniformBuff_Stat, nullptr);
    }


    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX, nullptr, BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_NONE);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX, nullptr, BIND_SHADER_RESOURCES_KEEP_EXISTING | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_NONE);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_MUT_DYN);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_KEEP_EXISTING | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_MUT_DYN);

    {
        {
            auto tex2D_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Mut"");
            ASSERT_NE(tex2D_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(tex2D_Mut, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            tex2D_Mut->Set(pRWTexSRVs[2]);
            EXPECT_EQ(tex2D_Mut->Get(0), pRWTexSRVs[2]);

            tex2D_Mut->Set(pRWTexSRVs[3], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Mut->Get(0), pRWTexSRVs[3]);
            tex2D_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(tex2D_Mut->Get(0), nullptr);

            tex2D_Mut->Set(pRWTexSRVs[4]);
            EXPECT_EQ(tex2D_Mut->Get(0), pRWTexSRVs[4]);
        }

        {
            auto tex2D_Mut_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Mut_sampler"");
            EXPECT_EQ(tex2D_Mut_sampler, nullptr);
        }

        {
            auto tex2D_MutArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_MutArr"");
            ASSERT_NE(tex2D_MutArr, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_MutArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(tex2D_MutArr, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            tex2D_MutArr->SetArray(pRWTexSRVs + 5, 0, 2);
            EXPECT_EQ(tex2D_MutArr->Get(0), pRWTexSRVs[5]);
        }

        {
            auto tex2D_MutArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_MutArr_sampler"");
            EXPECT_EQ(tex2D_MutArr_sampler, nullptr);
        }

        {
            auto tex2D_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Dyn"");
            ASSERT_NE(tex2D_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(tex2D_Dyn, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            tex2D_Dyn->Set(pRWTexSRVs[6]);
            EXPECT_EQ(tex2D_Dyn->Get(0), pRWTexSRVs[6]);
            tex2D_Dyn->Set(nullptr);
            EXPECT_EQ(tex2D_Dyn->Get(0), nullptr);
            tex2D_Dyn->Set(pRWTexSRVs[7]);
            EXPECT_EQ(tex2D_Dyn->Get(0), pRWTexSRVs[7]);
        }

        {
            auto tex2D_Dyn_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Dyn_sampler"");
            EXPECT_EQ(tex2D_Dyn_sampler, nullptr);
        }

        {
            auto tex2D_DynArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_DynArr"");
            ASSERT_NE(tex2D_DynArr, nullptr);
            ShaderResourceDesc ResDesc;
            tex2D_DynArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(tex2D_DynArr, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            tex2D_DynArr->SetArray(pSRVs, 0, 2);
            EXPECT_EQ(tex2D_DynArr->Get(0), pSRVs[0]);
            EXPECT_EQ(tex2D_DynArr->Get(1), pSRVs[1]);
        }

        {
            auto tex2D_DynArr_sampler = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_DynArr_sampler"");
            EXPECT_EQ(tex2D_DynArr_sampler, nullptr);
        }


        {
            auto UniformBuff_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""UniformBuff_Mut"");
            ASSERT_NE(UniformBuff_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Mut, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            UniformBuff_Mut->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Mut->Get(0), pUBs[0]);

            UniformBuff_Mut->Set(pUBs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Mut->Get(), pUBs[1]);
            UniformBuff_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(UniformBuff_Mut->Get(), nullptr);

            UniformBuff_Mut->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Mut->Get(), pUBs[0]);
        }

        {
            auto UniformBuff_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""UniformBuff_Dyn"");
            ASSERT_NE(UniformBuff_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            UniformBuff_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(UniformBuff_Dyn, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            UniformBuff_Dyn->Set(pUBs[1]);
            EXPECT_EQ(UniformBuff_Dyn->Get(0), pUBs[1]);
            UniformBuff_Dyn->Set(nullptr);
            EXPECT_EQ(UniformBuff_Dyn->Get(0), nullptr);
            UniformBuff_Dyn->Set(pUBs[0]);
            EXPECT_EQ(UniformBuff_Dyn->Get(0), pUBs[0]);
        }

        {
            auto Buffer_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_Mut"");
            ASSERT_NE(Buffer_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(Buffer_Mut, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            Buffer_Mut->Set(spRawBuffSRVs[1]);
            EXPECT_EQ(Buffer_Mut->Get(0), spRawBuffSRVs[1].RawPtr());

            Buffer_Mut->Set(spRawBuffSRVs[0], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(Buffer_Mut->Get(0), spRawBuffSRVs[0].RawPtr());
            Buffer_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(Buffer_Mut->Get(0), nullptr);

            Buffer_Mut->Set(spRawBuffSRVs[1]);
            EXPECT_EQ(Buffer_Mut->Get(0), spRawBuffSRVs[1].RawPtr());
        }

        {
            auto Buffer_MutArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_MutArr"");
            ASSERT_NE(Buffer_MutArr, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_MutArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(Buffer_MutArr, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            Buffer_MutArr->SetArray(&pFormattedBuffSRV, 0, 1);
            Buffer_MutArr->SetArray(&pFormattedBuffSRV, 1, 1);
            EXPECT_EQ(Buffer_MutArr->Get(0), pFormattedBuffSRV);
            EXPECT_EQ(Buffer_MutArr->Get(1), pFormattedBuffSRV);
        }

        {
            auto Buffer_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_Dyn"");
            ASSERT_NE(Buffer_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(Buffer_Dyn, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            Buffer_Dyn->Set(pFormattedBuffSRVs[2]);
            EXPECT_EQ(Buffer_Dyn->Get(0), pFormattedBuffSRVs[2]);
            Buffer_Dyn->Set(nullptr);
            EXPECT_EQ(Buffer_Dyn->Get(0), nullptr);
            Buffer_Dyn->Set(pFormattedBuffSRVs[3]);
            EXPECT_EQ(Buffer_Dyn->Get(0), pFormattedBuffSRVs[3]);
        }

        {
            auto Buffer_DynArr = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_DynArr"");
            ASSERT_NE(Buffer_DynArr, nullptr);
            ShaderResourceDesc ResDesc;
            Buffer_DynArr->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 2u);
            EXPECT_EQ(Buffer_DynArr, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            Buffer_DynArr->SetArray(&pFormattedBuffSRV, 0, 1);
            Buffer_DynArr->SetArray(&pFormattedBuffSRV, 1, 1);
            EXPECT_EQ(Buffer_DynArr->Get(0), pFormattedBuffSRV);
            EXPECT_EQ(Buffer_DynArr->Get(1), pFormattedBuffSRV);
        }

        {
            auto rwtex2D_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_rwtex2D_Mut"");
            ASSERT_NE(rwtex2D_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            rwtex2D_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwtex2D_Mut, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwtex2D_Mut->Set(pTexUAVs[0]);
            EXPECT_EQ(rwtex2D_Mut->Get(0), pTexUAVs[0]);

            rwtex2D_Mut->Set(pTexUAVs[1], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwtex2D_Mut->Get(0), pTexUAVs[1]);
            rwtex2D_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwtex2D_Mut->Get(0), nullptr);

            rwtex2D_Mut->Set(pTexUAVs[2]);
            EXPECT_EQ(rwtex2D_Mut->Get(0), pTexUAVs[2]);
        }

        {
            auto rwtex2D_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_rwtex2D_Dyn"");
            ASSERT_NE(rwtex2D_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            rwtex2D_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwtex2D_Dyn, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwtex2D_Dyn->Set(pTexUAVs[2]);
            EXPECT_EQ(rwtex2D_Dyn->Get(0), pTexUAVs[2]);
            rwtex2D_Dyn->Set(nullptr);
            EXPECT_EQ(rwtex2D_Dyn->Get(0), nullptr);
            rwtex2D_Dyn->Set(pTexUAVs[3]);
            EXPECT_EQ(rwtex2D_Dyn->Get(0), pTexUAVs[3]);
        }

        {
            auto rwBuff_Mut = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_rwBuff_Mut"");
            ASSERT_NE(rwBuff_Mut, nullptr);
            ShaderResourceDesc ResDesc;
            rwBuff_Mut->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwBuff_Mut, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwBuff_Mut->Set(pFormattedBuffUAV[1]);
            EXPECT_EQ(rwBuff_Mut->Get(0), pFormattedBuffUAV[1]);

            rwBuff_Mut->Set(pFormattedBuffUAV[0], SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwBuff_Mut->Get(0), pFormattedBuffUAV[0]);
            rwBuff_Mut->Set(nullptr, SET_SHADER_RESOURCE_FLAG_ALLOW_OVERWRITE);
            EXPECT_EQ(rwBuff_Mut->Get(0), nullptr);

            rwBuff_Mut->Set(pFormattedBuffUAV[1]);
            EXPECT_EQ(rwBuff_Mut->Get(0), pFormattedBuffUAV[1]);
        }

        {
            auto rwBuff_Dyn = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_rwBuff_Dyn"");
            ASSERT_NE(rwBuff_Dyn, nullptr);
            ShaderResourceDesc ResDesc;
            rwBuff_Dyn->GetResourceDesc(ResDesc);
            EXPECT_EQ(ResDesc.ArraySize, 1u);
            EXPECT_EQ(rwBuff_Dyn, pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name));
            rwBuff_Dyn->Set(pFormattedBuffUAV[1]);
            EXPECT_EQ(rwBuff_Dyn->Get(0), pFormattedBuffUAV[1]);
            rwBuff_Dyn->Set(nullptr);
            EXPECT_EQ(rwBuff_Dyn->Get(0), nullptr);
            rwBuff_Dyn->Set(pFormattedBuffUAV[2]);
            EXPECT_EQ(rwBuff_Dyn->Get(0), pFormattedBuffUAV[2]);
        }

        {
            auto tex2D_Static = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Static"");
            EXPECT_EQ(tex2D_Static, nullptr);
        }

        auto UniformBuff_Stat = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""UniformBuff_Stat"");
        EXPECT_EQ(UniformBuff_Stat, nullptr);
    }



    {
        auto NumVSVars = pSRB->GetVariableCount(SHADER_TYPE_VERTEX);
        for (Uint32 v = 0; v < NumVSVars; ++v)
        {
            auto pVar = pSRB->GetVariableByIndex(SHADER_TYPE_VERTEX, v);
            EXPECT_EQ(pVar->GetIndex(), v);
            EXPECT_TRUE(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
            ShaderResourceDesc ResDesc;
            pVar->GetResourceDesc(ResDesc);
            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ResDesc.Name);
            EXPECT_EQ(pVar, pVar2);
        }
    }

    {
        auto NumPSVars = pSRB->GetVariableCount(SHADER_TYPE_PIXEL);
        for (Uint32 v = 0; v < NumPSVars; ++v)
        {
            auto pVar = pSRB->GetVariableByIndex(SHADER_TYPE_PIXEL, v);
            EXPECT_EQ(pVar->GetIndex(), v);
            EXPECT_TRUE(pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE || pVar->GetType() == SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC);
            ShaderResourceDesc ResDesc;
            pVar->GetResourceDesc(ResDesc);
            auto pVar2 = pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ResDesc.Name);
            EXPECT_EQ(pVar, pVar2);
        }
    }

    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_NONE);
    EXPECT_EQ(pSRB->CheckResources(SHADER_TYPE_PIXEL, nullptr, BIND_SHADER_RESOURCES_KEEP_EXISTING | BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED), SHADER_RESOURCE_VARIABLE_TYPE_FLAG_NONE);

    pContext->SetRenderTargets(1, &pRTV, pDSV, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

    pContext->SetPipelineState(pTestPSO);
    pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

    DrawAttribs DrawAttrs(3, DRAW_FLAG_VERIFY_ALL);
    pContext->Draw(DrawAttrs);

    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_rwtex2D_Dyn"")->Set(pTexUAVs[7]);
    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_tex2D_Dyn"")->Set(pRWTexSRVs[3]);
    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_rwBuff_Dyn"")->Set(pFormattedBuffUAV[3]);
    pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""g_Buffer_Dyn"")->Set(pFormattedBuffSRVs[2]);

    {
        LOG_INFO_MESSAGE(""No worries about 3 warnings below: testing accessing variables from inactive shader stage"");
        auto pNonExistingVar = pSRB->GetVariableByName(SHADER_TYPE_GEOMETRY, ""g_NonExistingVar"");
        EXPECT_EQ(pNonExistingVar, nullptr);
        pNonExistingVar = pSRB->GetVariableByIndex(SHADER_TYPE_GEOMETRY, 4);
        EXPECT_EQ(pNonExistingVar, nullptr);
        EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_GEOMETRY), 0u);
    }

    float Zero[4] = {};
    pContext->ClearRenderTarget(pRTV, Zero, RESOURCE_STATE_TRANSITION_MODE_VERIFY);
    pContext->ClearDepthStencil(pDSV, CLEAR_DEPTH_FLAG, 1, 0, RESOURCE_STATE_TRANSITION_MODE_VERIFY);

    pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
    pContext->Draw(DrawAttrs);
}


TEST(ShaderResourceLayout, NoResourcesPSO)
{
    GPUTestingEnvironment::ScopedReset EnvironmentAutoReset;

    auto* const pEnv       = GPUTestingEnvironment::GetInstance();
    auto* const pDevice    = pEnv->GetDevice();
    auto* const pContext   = pEnv->GetDeviceContext();
    auto* const pSwapChain = pEnv->GetSwapChain();

    constexpr char   DummyVS[] = R""(
float4 main() : SV_Position
{
    return float4(0.0, 0.0, 0.0, 0.0);
}
)"";
    constexpr char   DummyPS[] = R""(
float4 main() : SV_Target
{
    return float4(0.0, 0.0, 0.0, 0.0);
}
)"";
    ShaderCreateInfo ShaderCI;
    ShaderCI.EntryPoint                 = ""main"";
    ShaderCI.UseCombinedTextureSamplers = true;
    ShaderCI.SourceLanguage             = SHADER_SOURCE_LANGUAGE_HLSL;

    RefCntAutoPtr<IShader> pVS;
    ShaderCI.Desc.Name       = ""DummyVS"";
    ShaderCI.Source          = DummyVS;
    ShaderCI.Desc.ShaderType = SHADER_TYPE_VERTEX;
    pDevice->CreateShader(ShaderCI, &pVS);
    ASSERT_NE(pVS, nullptr);

    RefCntAutoPtr<IShader> pPS;
    ShaderCI.Desc.Name       = ""DummyPS"";
    ShaderCI.Source          = DummyPS;
    ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
    pDevice->CreateShader(ShaderCI, &pPS);
    ASSERT_NE(pPS, nullptr);

    GraphicsPipelineStateCreateInfo PSOCreateInfo;

    auto& PSODesc          = PSOCreateInfo.PSODesc;
    auto& GraphicsPipeline = PSOCreateInfo.GraphicsPipeline;

    PSODesc.Name                     = ""No resources PSO"";
    PSODesc.SRBAllocationGranularity = 16;

    GraphicsPipeline.NumRenderTargets = 1;
    GraphicsPipeline.RTVFormats[0]    = TEX_FORMAT_RGBA8_UNORM;

    PSOCreateInfo.pVS = pVS;
    PSOCreateInfo.pPS = pPS;

    RefCntAutoPtr<IPipelineState> pPSO;
    pDevice->CreateGraphicsPipelineState(PSOCreateInfo, &pPSO);
    ASSERT_NE(pPSO, nullptr);

    EXPECT_EQ(pPSO->GetStaticVariableCount(SHADER_TYPE_VERTEX), 0u);
    EXPECT_EQ(pPSO->GetStaticVariableCount(SHADER_TYPE_PIXEL), 0u);
    EXPECT_EQ(pPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, ""NonexistentResource""), nullptr);
    EXPECT_EQ(pPSO->GetStaticVariableByName(SHADER_TYPE_PIXEL, ""NonexistentResource""), nullptr);
    EXPECT_EQ(pPSO->GetStaticVariableByIndex(SHADER_TYPE_VERTEX, 0), nullptr);
    EXPECT_EQ(pPSO->GetStaticVariableByIndex(SHADER_TYPE_PIXEL, 0), nullptr);

    RefCntAutoPtr<IShaderResourceBinding> pSRB;
    pPSO->CreateShaderResourceBinding(&pSRB, true);

    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_VERTEX), 0u);
    EXPECT_EQ(pSRB->GetVariableCount(SHADER_TYPE_PIXEL), 0u);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_VERTEX, ""NonexistentResource""), nullptr);
    EXPECT_EQ(pSRB->GetVariableByName(SHADER_TYPE_PIXEL, ""NonexistentResource""), nullptr);

    ITextureView* ppRTVs[] = {pSwapChain->GetCurrentBackBufferRTV()};
    pContext->SetRenderTargets(1, ppRTVs, nullptr, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
    float ClearColor[] = {0.125, 0.375, 0.125, 0.75};
    pContext->ClearRenderTarget(ppRTVs[0], ClearColor, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

    pContext->SetPipelineState(pPSO);
    pContext->CommitShaderResources(pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

    pContext->Draw(DrawAttribs{3, DRAW_FLAG_VERIFY_ALL});
}

} // namespace
",16313,True,3957.1613555484,median
"// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
// --------------------------------------------------------------------------------
// DomainFile.cpp
//

// --------------------------------------------------------------------------------


#include ""common.h""

// --------------------------------------------------------------------------------
// Headers
// --------------------------------------------------------------------------------

#include <shlwapi.h>

#include ""invokeutil.h""
#include ""eeconfig.h""
#include ""dynamicmethod.h""
#include ""field.h""
#include ""dbginterface.h""
#include ""eventtrace.h""

#ifdef FEATURE_PREJIT
#include <corcompile.h>
#include ""compile.h""
#endif  // FEATURE_PREJIT

#include ""dllimportcallback.h""
#include ""peimagelayout.inl""

#include ""winrthelpers.h""

#ifdef FEATURE_PERFMAP
#include ""perfmap.h""
#endif // FEATURE_PERFMAP

#ifndef DACCESS_COMPILE
DomainFile::DomainFile(AppDomain *pDomain, PEFile *pFile)
  : m_pDomain(pDomain),
    m_pFile(pFile),
    m_pOriginalFile(NULL),
    m_pModule(NULL),
    m_level(FILE_LOAD_CREATE),
    m_pError(NULL),
    m_notifyflags(NOT_NOTIFIED),
    m_loading(TRUE),
    m_pDynamicMethodTable(NULL),
    m_pUMThunkHash(NULL),
    m_bDisableActivationCheck(FALSE),
    m_dwReasonForRejectingNativeImage(0)
{
    CONTRACTL
    {
        CONSTRUCTOR_CHECK;
        THROWS;  // From CreateHandle
        GC_NOTRIGGER;
        MODE_ANY;
        FORBID_FAULT;
    }
    CONTRACTL_END;

    m_hExposedModuleObject = NULL;
    pFile->AddRef();
}

DomainFile::~DomainFile()
{
    CONTRACTL
    {
        DESTRUCTOR_CHECK;
        NOTHROW;
        GC_TRIGGERS;
        MODE_ANY;
    }
    CONTRACTL_END;

    m_pFile->Release();
    if(m_pOriginalFile)
        m_pOriginalFile->Release();
    if (m_pDynamicMethodTable)
        m_pDynamicMethodTable->Destroy();
    delete m_pError;
}

#endif //!DACCESS_COMPILE

LoaderAllocator * DomainFile::GetLoaderAllocator()
{
    CONTRACTL
    {
        NOTHROW;
        GC_NOTRIGGER;
        MODE_ANY;
    }
    CONTRACTL_END;
    Assembly *pAssembly = GetDomainAssembly()->GetAssembly();
    if ((pAssembly != NULL) && (pAssembly->IsCollectible()))
    {
        return pAssembly->GetLoaderAllocator();
    }
    else
    {
        return this->GetAppDomain()->GetLoaderAllocator();
    }
}

#ifndef DACCESS_COMPILE

// Optimization intended for EnsureLoadLevel only
#include <optsmallperfcritical.h>
void DomainFile::EnsureLoadLevel(FileLoadLevel targetLevel)
{
    CONTRACT_VOID
    {
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
    }
    CONTRACT_END;

    TRIGGERSGC ();
    if (IsLoading())
    {
        this->GetAppDomain()->LoadDomainFile(this, targetLevel);

        // Enforce the loading requirement.  Note that we may have a deadlock in which case we
        // may be off by one which is OK.  (At this point if we are short of targetLevel we know
        // we have done so because of reentrancy contraints.)

        RequireLoadLevel((FileLoadLevel)(targetLevel-1));
    }
    else
        ThrowIfError(targetLevel);

    RETURN;
}
#include <optdefault.h>

void DomainFile::AttemptLoadLevel(FileLoadLevel targetLevel)
{
    CONTRACT_VOID
    {
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
    }
    CONTRACT_END;

    if (IsLoading())
        this->GetAppDomain()->LoadDomainFile(this, targetLevel);
    else
        ThrowIfError(targetLevel);

    RETURN;
}


CHECK DomainFile::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        NOTHROW;
        GC_NOTRIGGER;
    }
    CONTRACTL_END;

    if (deadlockOK)
    {
#ifndef CROSSGEN_COMPILE
        // CheckLoading requires waiting on a host-breakable lock.
        // Since this is only a checked-build assert and we've been
        // living with it for a while, I'll leave it as is.
        //@TODO: CHECK statements are *NOT* debug-only!!!
        CONTRACT_VIOLATION(ThrowsViolation|GCViolation|TakesLockViolation);
        CHECK(this->GetAppDomain()->CheckLoading(this, requiredLevel));
#endif
    }
    else
    {
        CHECK_MSG(m_level >= requiredLevel,
                  ""File not sufficiently loaded"");
    }

    CHECK_OK;
}



void DomainFile::RequireLoadLevel(FileLoadLevel targetLevel)
{
    CONTRACT_VOID
    {
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
    }
    CONTRACT_END;

    if (GetLoadLevel() < targetLevel)
    {
        ThrowIfError(targetLevel);
        ThrowHR(MSEE_E_ASSEMBLYLOADINPROGRESS); // @todo: better exception
    }

    RETURN;
}


void DomainFile::SetError(Exception *ex)
{
    CONTRACT_VOID
    {
        PRECONDITION(!IsError());
        PRECONDITION(ex != NULL);
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
        POSTCONDITION(IsError());
    }
    CONTRACT_END;

    m_pError = new ExInfo(ex->DomainBoundClone());

    GetCurrentModule()->NotifyEtwLoadFinished(ex->GetHR());

    if (!IsProfilerNotified())
    {
        SetProfilerNotified();

#ifdef PROFILING_SUPPORTED
        if (GetCurrentModule() != NULL)
        {
            // Only send errors for non-shared assemblies; other assemblies might be successfully completed
            // in another app domain later.
            GetCurrentModule()->NotifyProfilerLoadFinished(ex->GetHR());
        }
#endif
    }

    RETURN;
}

void DomainFile::ThrowIfError(FileLoadLevel targetLevel)
{
    CONTRACT_VOID
    {
        INSTANCE_CHECK;
        MODE_ANY;
        THROWS;
        GC_TRIGGERS;
    }
    CONTRACT_END;

    if (m_level < targetLevel)
    {
        if (m_pError)
            m_pError->Throw();
    }

    RETURN;
}

CHECK DomainFile::CheckNoError(FileLoadLevel targetLevel)
{
    LIMITED_METHOD_CONTRACT;
    CHECK(m_level >= targetLevel
          || !IsError());

    CHECK_OK;
}

CHECK DomainFile::CheckLoaded()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        NOTHROW;
        GC_NOTRIGGER;
        MODE_ANY;
    }
    CONTRACTL_END;

    CHECK_MSG(CheckNoError(FILE_LOADED), ""DomainFile load resulted in an error"");

    if (IsLoaded())
        CHECK_OK;

    // Mscorlib is allowed to run managed code much earlier than other
    // assemblies for bootstrapping purposes.  This is because it has no
    // dependencies, security checks, and doesn't rely on loader notifications.

    if (GetFile()->IsSystem())
        CHECK_OK;

    CHECK_MSG(GetFile()->CheckLoaded(), ""PEFile has not been loaded"");

    CHECK_OK;
}

CHECK DomainFile::CheckActivated()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        NOTHROW;
        GC_NOTRIGGER;
        MODE_ANY;
    }
    CONTRACTL_END;

    CHECK_MSG(CheckNoError(FILE_ACTIVE), ""DomainFile load resulted in an error"");

    if (IsActive())
        CHECK_OK;

    // Mscorlib is allowed to run managed code much earlier than other
    // assemblies for bootstrapping purposes.  This is because it has no
    // dependencies, security checks, and doesn't rely on loader notifications.

    if (GetFile()->IsSystem())
        CHECK_OK;

    CHECK_MSG(GetFile()->CheckLoaded(), ""PEFile has not been loaded"");
    CHECK_MSG(IsLoaded(), ""DomainFile has not been fully loaded"");
    CHECK_MSG(m_bDisableActivationCheck || CheckLoadLevel(FILE_ACTIVE), ""File has not had execution verified"");

    CHECK_OK;
}

#endif //!DACCESS_COMPILE

DomainAssembly *DomainFile::GetDomainAssembly()
{
    CONTRACTL
    {
        SUPPORTS_DAC;
        NOTHROW;
        GC_NOTRIGGER;
    }
    CONTRACTL_END;

    _ASSERTE(IsAssembly());
    return (DomainAssembly *) this;
}

// Return true iff the debugger should get notifications about this assembly.
//
// Notes:
//   The debuggee may be stopped while a DomainAssmebly is being initialized.  In this time window,
//   GetAssembly() may be NULL.  If that's the case, this function has to return FALSE.  Later on, when
//   the DomainAssembly is fully initialized, this function will return TRUE.  This is the only scenario
//   where this function is mutable.  In other words, a DomainAssembly can only change from being invisible
//   to visible, but NOT vice versa.  Once a DomainAssmebly is fully initialized, this function should be
//   immutable for an instance of a module. That ensures that the debugger gets consistent
//   notifications about it. It this value mutates, than the debugger may miss relevant notifications.
BOOL DomainAssembly::IsVisibleToDebugger()
{
    WRAPPER_NO_CONTRACT;
    SUPPORTS_DAC;

    return (GetAssembly() != NULL);
}

#ifndef DACCESS_COMPILE
#ifdef FEATURE_PREJIT
void DomainFile::ExternalLog(DWORD level, const WCHAR *fmt, ...)
{
    WRAPPER_NO_CONTRACT;

    va_list args;
    va_start(args, fmt);

    GetOriginalFile()->ExternalVLog(LF_ZAP, level, fmt, args);

    va_end(args);
}

void DomainFile::ExternalLog(DWORD level, const char *msg)
{
    WRAPPER_NO_CONTRACT;

    GetOriginalFile()->ExternalLog(level, msg);
}
#endif

#ifndef CROSSGEN_COMPILE
//---------------------------------------------------------------------------------------
//
// Returns managed representation of the module (Module or ModuleBuilder).
// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
//
OBJECTREF DomainFile::GetExposedModuleObject()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        MODE_COOPERATIVE;
        GC_TRIGGERS;
    }
    CONTRACTL_END;

    LoaderAllocator * pLoaderAllocator = GetLoaderAllocator();

    if (m_hExposedModuleObject == NULL)
    {
        // Atomically create a handle
        LOADERHANDLE handle = pLoaderAllocator->AllocateHandle(NULL);

        FastInterlockCompareExchangePointer(&m_hExposedModuleObject, handle, static_cast<LOADERHANDLE>(NULL));
    }

    if (pLoaderAllocator->GetHandleValue(m_hExposedModuleObject) == NULL)
    {
        REFLECTMODULEBASEREF refClass = NULL;

        // Will be TRUE only if LoaderAllocator managed object was already collected and therefore we should
        // return NULL
        BOOL fIsLoaderAllocatorCollected = FALSE;

        GCPROTECT_BEGIN(refClass);

        if (GetFile()->IsDynamic())
        {
            refClass = (REFLECTMODULEBASEREF) AllocateObject(MscorlibBinder::GetClass(CLASS__MODULE_BUILDER));
        }
        else
        {
            refClass = (REFLECTMODULEBASEREF) AllocateObject(MscorlibBinder::GetClass(CLASS__MODULE));
        }
        refClass->SetModule(m_pModule);

        // Attach the reference to the assembly to keep the LoaderAllocator for this collectible type
        // alive as long as a reference to the module is kept alive.
        if (GetModule()->GetAssembly() != NULL)
        {
            OBJECTREF refAssembly = GetModule()->GetAssembly()->GetExposedObject();
            if ((refAssembly == NULL) && GetModule()->GetAssembly()->IsCollectible())
            {
                fIsLoaderAllocatorCollected = TRUE;
            }
            refClass->SetAssembly(refAssembly);
        }

        pLoaderAllocator->CompareExchangeValueInHandle(m_hExposedModuleObject, (OBJECTREF)refClass, NULL);
        GCPROTECT_END();

        if (fIsLoaderAllocatorCollected)
        {   // The LoaderAllocator managed object was already collected, we cannot re-create it
            // Note: We did not publish the allocated Module/ModuleBuilder object, it will get collected
            // by GC
            return NULL;
        }
    }

    return pLoaderAllocator->GetHandleValue(m_hExposedModuleObject);
} // DomainFile::GetExposedModuleObject
#endif // CROSSGEN_COMPILE

BOOL DomainFile::DoIncrementalLoad(FileLoadLevel level)
{
    STANDARD_VM_CONTRACT;

    if (IsError())
        return FALSE;

    Thread *pThread;
    pThread = GetThread();
    _ASSERTE(pThread);

    switch (level)
    {
    case FILE_LOAD_BEGIN:
        Begin();
        break;

    case FILE_LOAD_FIND_NATIVE_IMAGE:
#ifdef FEATURE_PREJIT
        FindNativeImage();
#endif
        break;

    case FILE_LOAD_VERIFY_NATIVE_IMAGE_DEPENDENCIES:
#ifdef FEATURE_PREJIT
        VerifyNativeImageDependencies();
#endif
        break;

    case FILE_LOAD_ALLOCATE:
        Allocate();
        break;

    case FILE_LOAD_ADD_DEPENDENCIES:
        AddDependencies();
        break;

    case FILE_LOAD_PRE_LOADLIBRARY:
        PreLoadLibrary();
        break;

    case FILE_LOAD_LOADLIBRARY:
        LoadLibrary();
        break;

    case FILE_LOAD_POST_LOADLIBRARY:
        PostLoadLibrary();
        break;

    case FILE_LOAD_EAGER_FIXUPS:
        EagerFixups();
        break;

    case FILE_LOAD_DELIVER_EVENTS:
        DeliverSyncEvents();
        break;

    case FILE_LOAD_VTABLE_FIXUPS:
        VtableFixups();
        break;

    case FILE_LOADED:
        FinishLoad();
        break;

    case FILE_ACTIVE:
        Activate();
        break;

    default:
        UNREACHABLE();
    }

#ifdef FEATURE_MULTICOREJIT
    {
        Module * pModule = GetModule();

        if (pModule != NULL) // Should not triggle assert when module is NULL
        {
            this->GetAppDomain()->GetMulticoreJitManager().RecordModuleLoad(pModule, level);
        }
    }
#endif

    return TRUE;
}

#ifdef FEATURE_PREJIT

void DomainFile::VerifyNativeImageDependencies(bool verifyOnly)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
        PRECONDITION(verifyOnly || (m_pDomain->GetDomainFileLoadLevel(this) ==
                                    FILE_LOAD_FIND_NATIVE_IMAGE));
    }
    CONTRACTL_END;

    // This function gets called multiple times. The first call is the real work.
    // Subsequent calls are only to verify that everything still looks OK.
    if (!verifyOnly)
        ClearNativeImageStress();

    if (!m_pFile->HasNativeImage())
    {
        CheckZapRequired();
        return;
    }

    {
    // Go through native dependencies & make sure they still have their prejit images after
    // the security check.
    // NOTE: we could theoretically do this without loading the dependencies, if we cache the
    // COR_TRUST structures from the dependencies in the version information.
    //
    // Verify that all of our hard dependencies are loaded at the right base address.
    // If not, abandon prejit image (or fix ours up)
    // Also, if there are any hard dependencies, then our native image also needs to be
    // loaded at the right base address

    // Note: we will go through all of our dependencies, call Load on them, and check the base
    // addresses & identity.
    // It is important to note that all of those dependencies are also going to do the
    // same thing, so we might conceivably check a base address as OK, and then have that image
    // abandoned by that assembly during its VerifyNativeImageDependencies phase.
    // However, we avoid this problem since the hard depedencies stored are a closure of the
    // hard dependencies of an image.  This effectively means that our check here is a superset
    // of the check that the dependencies will perform.  Even if we hit a dependency loop, we
    // will still guarantee that we've examined all of our dependencies.

    ReleaseHolder<PEImage> pNativeImage = m_pFile->GetNativeImageWithRef();
    if(pNativeImage==NULL)
    {
        CheckZapRequired();
        return;
    }

    PEImageLayout* pNativeLayout = pNativeImage->GetLoadedLayout();

    // reuse same codepath for both manifest and non-manifest modules
    ReleaseHolder<PEImage> pManifestNativeImage(NULL);

    PEFile* pManifestFile = m_pFile;
    PEImageLayout* pManifestNativeLayout = pNativeLayout;

    if (!IsAssembly())
    {
        pManifestFile = GetDomainAssembly()->GetCurrentAssembly()
            ->GetManifestModule()->GetFile();

        pManifestNativeImage = pManifestFile->GetNativeImageWithRef();

        if (pManifestNativeImage == NULL)
        {
            ExternalLog(LL_ERROR, ""Rejecting native image because there is no ""
                ""ngen image for manifest module. Check why the manifest module ""
                ""does not have an ngen image"");
            m_dwReasonForRejectingNativeImage = ReasonForRejectingNativeImage_NoNiForManifestModule;
            STRESS_LOG3(LF_ZAP,LL_INFO100,""Rejecting native file %p, because its manifest module %p has no NI - reason 0x%x\\n"",pNativeImage.GetValue(),pManifestFile,m_dwReasonForRejectingNativeImage);
            goto NativeImageRejected;
        }

        return;
    }

    COUNT_T cDependencies;
    CORCOMPILE_DEPENDENCY *pDependencies = pManifestNativeLayout->GetNativeDependencies(&cDependencies);

    LOG((LF_ZAP, LL_INFO100, ""ZAP: Checking native image dependencies for %S.\\n"",
         pNativeImage->GetPath().GetUnicode()));

    for (COUNT_T iDependency = 0; iDependency < cDependencies; iDependency++)
    {
        CORCOMPILE_DEPENDENCY *pDependency = &(pDependencies[iDependency]);

        // Later, for domain neutral assemblies, we will also want to verify security policy
        // in such cases, the prejit image should store the publisher info for the dependencies
        // for us.

        // If this is not a hard-bound dependency, then skip to the next dependency
        if (pDependency->signNativeImage == INVALID_NGEN_SIGNATURE)
            continue;


        //
        // CoreCLR hard binds to mscorlib.dll only. Avoid going through the full load.
        //

#ifdef _DEBUG
        AssemblySpec name;
        name.InitializeSpec(pDependency->dwAssemblyRef,
                            ((pManifestNativeImage != NULL) ? pManifestNativeImage : pNativeImage)->GetNativeMDImport(),
                            GetDomainAssembly());
        _ASSERTE(name.IsMscorlib());
#endif

        PEAssembly * pDependencyFile = SystemDomain::SystemFile();


        ReleaseHolder<PEImage> pDependencyNativeImage = pDependencyFile->GetNativeImageWithRef();
        if (pDependencyNativeImage == NULL)
        {
            ExternalLog(LL_ERROR, W(""Rejecting native image because dependency %s is not native""),
                        pDependencyFile->GetPath().GetUnicode());
            m_dwReasonForRejectingNativeImage = ReasonForRejectingNativeImage_DependencyNotNative;
            STRESS_LOG3(LF_ZAP,LL_INFO100,""Rejecting native file %p, because dependency %p is not NI - reason 0x%x\\n"",pNativeImage.GetValue(),pDependencyFile,m_dwReasonForRejectingNativeImage);
            goto NativeImageRejected;
        }

        PTR_PEImageLayout pDependencyNativeLayout = pDependencyNativeImage->GetLoadedLayout();
        // Assert that the native image signature is as expected
        // Fusion will ensure this
        CORCOMPILE_VERSION_INFO * pDependencyNativeVersion =
                pDependencyNativeLayout->GetNativeVersionInfo();

        if (!RuntimeVerifyNativeImageDependency(pDependency, pDependencyNativeVersion, pDependencyFile))
            goto NativeImageRejected;
    }
    LOG((LF_ZAP, LL_INFO100, ""ZAP: Native image dependencies for %S OK.\\n"",
            pNativeImage->GetPath().GetUnicode()));

    return;
}

NativeImageRejected:
    m_pFile->ClearNativeImage();

    CheckZapRequired();

    return;
}

BOOL DomainFile::IsZapRequired()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    if (!m_pFile->HasMetadata() || !g_pConfig->RequireZap(GetSimpleName()))
        return FALSE;

#if defined(_DEBUG)
    // If we're intentionally treating NIs as if they were MSIL assemblies, and the test
    // is flexible enough to accept that (e.g., complus_zaprequired=2), then zaps are not
    // required (i.e., it's ok for m_pFile->m_nativeImage to be NULL), but only if we
    // loaded an actual NI to be treated as an IL assembly
    if (PEFile::ShouldTreatNIAsMSIL())
    {
        // Since the RequireZap() call above returned true, we know that some level of
        // zap requiredness was configured
        _ASSERTE(g_pConfig->RequireZaps() != EEConfig::REQUIRE_ZAPS_NONE);

        // If config uses this special value (2), zaps are not required, so long as
        // we're using an actual NI as IL
        if ((g_pConfig->RequireZaps() == EEConfig::REQUIRE_ZAPS_ALL_JIT_OK) &&
            m_pFile->HasOpenedILimage() &&
            m_pFile->GetOpenedILimage()->HasNativeHeader())
        {
            return FALSE;
        }
    }
#endif // defined(_DEBUG)

    // Does this look like a resource-only assembly?  We assume an assembly is resource-only
    // if it contains no TypeDef (other than the <Module> TypeDef) and no MethodDef.
    // Note that pMD->GetCountWithTokenKind(mdtTypeDef) doesn't count the <Module> type.
    IMDInternalImportHolder pMD = m_pFile->GetMDImport();
    if (pMD->GetCountWithTokenKind(mdtTypeDef) == 0 && pMD->GetCountWithTokenKind(mdtMethodDef) == 0)
        return FALSE;

    DomainAssembly * pDomainAssembly = GetDomainAssembly();

#ifdef FEATURE_NATIVE_IMAGE_GENERATION
    if (IsCompilationProcess())
    {
        // Ignore the assembly being ngened.

        bool fileIsBeingNGened = false;

        if (this->GetAppDomain()->IsCompilationDomain())
        {
            Assembly * assemblyBeingNGened = this->GetAppDomain()->ToCompilationDomain()->GetTargetAssembly();
            if (assemblyBeingNGened == NULL || assemblyBeingNGened == pDomainAssembly->GetCurrentAssembly())
                fileIsBeingNGened = true;
        }
        else if (IsSystem())
        {
            // mscorlib gets loaded before the CompilationDomain gets created.
            // However, we may be ngening mscorlib itself
            fileIsBeingNGened = true;
        }

        if (fileIsBeingNGened)
            return FALSE;
    }
#endif

    return TRUE;
}

void DomainFile::CheckZapRequired()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    if (m_pFile->HasNativeImage() || !IsZapRequired())
        return;

#ifdef FEATURE_READYTORUN
    if(m_pFile->GetLoaded()->HasReadyToRunHeader())
        return;
#endif

    // Flush any log messages
    GetFile()->FlushExternalLog();

    StackSString ss;
    ss.Printf(""ZapRequire: Could not get native image for %s.\\n"",
              GetSimpleName());

#if defined(_DEBUG)
    // Assert as some test may not check their error codes well. So throwing an
    // exception may not cause a test failure (as it should).
    StackScratchBuffer scratch;
    DbgAssertDialog(__FILE__, __LINE__, (char*)ss.GetUTF8(scratch));
#endif // defined(_DEBUG)

    COMPlusThrowNonLocalized(kFileNotFoundException, ss.GetUnicode());
}

// Discarding an ngen image can cause problems. For more coverage,
// this stress-mode discards ngen images even if not needed.

void DomainFile::ClearNativeImageStress()
{
    WRAPPER_NO_CONTRACT;

#ifdef _DEBUG
    static ConfigDWORD clearNativeImageStress;
    DWORD stressPercentage = clearNativeImageStress.val(CLRConfig::INTERNAL_clearNativeImageStress);
    _ASSERTE(stressPercentage <= 100);
    if (stressPercentage == 0 || !GetFile()->HasNativeImage())
        return;

    // Note that discarding a native image can affect dependencies. So its not enough
    // to only check DomainFile::IsZapRequired() here.
    if (g_pConfig->RequireZaps() != EEConfig::REQUIRE_ZAPS_NONE)
        return;

    if (g_IBCLogger.InstrEnabled())
        return;

    ULONG hash = HashStringA(GetSimpleName());

    // Hash in the FileLoadLevel so that we make a different decision for every level.
    FileLoadLevel fileLoadLevel = m_pDomain->GetDomainFileLoadLevel(this);
    hash ^= ULONG(fileLoadLevel);
    // We do not discard native images after this level
    _ASSERTE(fileLoadLevel < FILE_LOAD_VERIFY_NATIVE_IMAGE_DEPENDENCIES);

    // Different app-domains should make different decisions
    hash ^= HashString(this->GetAppDomain()->GetFriendlyName());

#ifdef FEATURE_NATIVE_IMAGE_GENERATION
    // Since DbgRandomOnHashAndExe() is not so random under ngen.exe, also
    // factor in the module being compiled
    if (this->GetAppDomain()->IsCompilationDomain())
    {
        Module * module = this->GetAppDomain()->ToCompilationDomain()->GetTargetModule();
        // Has the target module been set yet?
        if (module)
            hash ^= HashStringA(module->GetSimpleName());
    }
#endif

    if (DbgRandomOnHashAndExe(hash, float(stressPercentage)/100))
    {
        GetFile()->ClearNativeImage();
        ExternalLog(LL_ERROR, ""Rejecting native image for **clearNativeImageStress**"");
    }
#endif
}

#endif // FEATURE_PREJIT

void DomainFile::PreLoadLibrary()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

} // DomainFile::PreLoadLibrary

// Note that this is the sole loading function which must be called OUTSIDE THE LOCK, since
// it will potentially involve the OS loader lock.
void DomainFile::LoadLibrary()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

    GetFile()->LoadLibrary();
}

void DomainFile::PostLoadLibrary()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        // Note that GetFile()->LoadLibrary must be called before this OUTSIDE OF THE LOCKS
        PRECONDITION(GetFile()->CheckLoaded());
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

#ifdef FEATURE_PREJIT
    if (GetFile()->HasNativeImage())
    {
        InsertIntoDomainFileWithNativeImageList();
    }
#endif
#ifdef PROFILING_SUPPORTED
    // After this point, it is possible to load types.
    // We need to notify the profiler now because the profiler may need to inject methods into
    // the module, and to do so reliably, it must have the chance to do so before
    // any types are loaded from the module.
    //
    // In the past we only allowed injecting types/methods on non-NGEN images so notifying here
    // worked ok, but for NGEN images this is pretty ugly. Rejitting often occurs in this callback,
    // but then during fixup the results of LoadedMethodDesc iterator would change and we would
    // need to re-iterate everything. Aside from Rejit other code often wasn't designed to handle
    // running before Fixup. A concrete example VS recently hit, calling GetClassLayout using
    // a MethodTable which doesn't need restore but its parent pointer isn't fixed up yet.
    // We've already set the rules so that profilers can't modify the member list of types in NGEN images
    // so it doesn't matter if types are pre-loaded. We only need the guarantee that code for the
    // loaded types won't execute yet. For NGEN images we deliver the load notification in
    // FILE_LOAD_DELIVER_EVENTS.
    if (!GetFile()->HasNativeImage())
    {
        if (!IsProfilerNotified())
        {
            SetProfilerNotified();
            GetCurrentModule()->NotifyProfilerLoadFinished(S_OK);
        }
    }

#endif
}

void DomainFile::AddDependencies()
{
    STANDARD_VM_CONTRACT;
}

void DomainFile::EagerFixups()
{
    WRAPPER_NO_CONTRACT;

#ifdef FEATURE_PREJIT
    if (GetCurrentModule()->HasNativeImage())
    {
        GetCurrentModule()->RunEagerFixups();
    }
    else
#endif // FEATURE_PREJIT
#ifdef FEATURE_READYTORUN
    if (GetCurrentModule()->IsReadyToRun())
    {
#ifndef CROSSGEN_COMPILE
        GetCurrentModule()->RunEagerFixups();
#endif

        PEImageLayout * pLayout = GetCurrentModule()->GetReadyToRunInfo()->GetImage();

        TADDR base = dac_cast<TADDR>(pLayout->GetBase());

        ExecutionManager::AddCodeRange(base, base + (TADDR)pLayout->GetVirtualSize(),
                                        ExecutionManager::GetReadyToRunJitManager(),
                                         RangeSection::RANGE_SECTION_READYTORUN,
                                         GetCurrentModule() /* (void *)pLayout */);
    }
#endif // FEATURE_READYTORUN
}

void DomainFile::VtableFixups()
{
    WRAPPER_NO_CONTRACT;

#if !defined(CROSSGEN_COMPILE)
    if (!GetCurrentModule()->IsResource())
        GetCurrentModule()->FixupVTables();
#endif // !CROSSGEN_COMPILE
}

void DomainFile::FinishLoad()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

#ifdef FEATURE_PREJIT

    if (m_pFile->HasNativeImage())
    {

        LOG((LF_ZAP, LL_INFO10, ""Using native image %S.\\n"", m_pFile->GetPersistentNativeImage()->GetPath().GetUnicode()));
        ExternalLog(LL_INFO10, ""Native image successfully used."");

        // Inform metadata that it has been loaded from a native image
        // (and so there was an opportunity to check for or fix inconsistencies in the original IL metadata)
        m_pFile->GetMDImport()->SetVerifiedByTrustedSource(TRUE);
    }

    // Are we absolutely required to use a native image?
    CheckZapRequired();

#if defined(FEATURE_COMINTEROP)
    // If this is a winmd file, ensure that the ngen reference namespace is loadable.
    // This is necessary as on the phone we don't check ngen image dependencies, and thus we can get in a situation
    // where a winmd is loaded as a dependency of an ngen image, but the type used to build cross module references
    // in winmd files isn't loaded.
    PEFile* peFile = GetFile();
    if (peFile && peFile->AsAssembly()->IsWindowsRuntime() && peFile->HasHostAssembly())
    {
        IMDInternalImport *pImport = GetFile()->GetPersistentMDImport();
        LPCSTR  szNameSpace;
        LPCSTR  szTypeName;
        // It does not make sense to pass the file name to recieve fake type name for empty WinMDs, because we would use the name
        // for binding in next call to BindAssemblySpec which would fail for fake WinRT type name
        // We will throw/return the error instead and the caller will recognize it and react to it by not creating the ngen image -
        // see code:Zapper::ComputeDependenciesInCurrentDomain
        if (SUCCEEDED(::GetFirstWinRTTypeDef(pImport, &szNameSpace, &szTypeName, NULL, NULL)))
        {
            // Build assembly spec to describe binding to that WinRT type.
            AssemblySpec spec;
            IfFailThrow(spec.Init(""WindowsRuntimeAssemblyName, ContentType=WindowsRuntime""));
            spec.SetWindowsRuntimeType(szNameSpace, szTypeName);

            // Bind to assembly using the CLRPriv binder infrastructure. (All WinRT loads are done through CLRPriv binders
            ReleaseHolder<IAssemblyName> pAssemblyName;
            IfFailThrow(spec.CreateFusionName(&pAssemblyName, FALSE, TRUE));
            ReleaseHolder<ICLRPrivAssembly> pPrivAssembly;
            IfFailThrow(GetFile()->GetHostAssembly()->BindAssemblyByName(pAssemblyName, &pPrivAssembly));

            // Verify that we found this. If this invariant doesn't hold, then the ngen images that reference this winmd are be invalid.
            // ALSO, this winmd file is invalid as it doesn't follow spec about how it is distributed.
            if (GetAppDomain()->FindAssembly(pPrivAssembly) != this)
            {
                ThrowHR(COR_E_BADIMAGEFORMAT);
            }
        }
    }
#endif //defined(FEATURE_COMINTEROP)
#endif // FEATURE_PREJIT

    // Flush any log messages
#ifdef FEATURE_PREJIT
    GetFile()->FlushExternalLog();
#endif
    // Must set this a bit prematurely for the DAC stuff to work
    m_level = FILE_LOADED;

    // Now the DAC can find this module by enumerating assemblies in a domain.
    DACNotify::DoModuleLoadNotification(m_pModule);

#if defined(DEBUGGING_SUPPORTED) && !defined(DACCESS_COMPILE)
    if (IsDebuggerNotified() && (g_pDebugInterface != NULL))
    {
        // We already notified dbgapi that this module was loading (via LoadModule()).
        // Now let the dbgapi know the module has reached FILE_LOADED, so it can do any
        // processing that needs to wait until this stage (e.g., binding breakpoints in
        // NGENd generics).
        g_pDebugInterface->LoadModuleFinished(m_pModule, m_pDomain);
    }
#endif // defined(DEBUGGING_SUPPORTED) && !defined(DACCESS_COMPILE)

    // Set a bit to indicate that the module has been loaded in some domain, and therefore
    // typeloads can involve types from this module. (Used for candidate instantiations.)
    GetModule()->SetIsReadyForTypeLoad();

#ifdef FEATURE_PERFMAP
    // Notify the perfmap of the IL image load.
    PerfMap::LogImageLoad(m_pFile);
#endif
}

void DomainFile::Activate()
{
    CONTRACT_VOID
    {
        INSTANCE_CHECK;
        PRECONDITION(IsLoaded());
        STANDARD_VM_CHECK;
    }
    CONTRACT_END;

    // If we are a module, ensure we've activated the assembly first.

    if (!IsAssembly())
    {
        GetDomainAssembly()->EnsureActive();
    }
    else
    {
        // We cannot execute any code in this assembly until we know what exception plan it is on.
        // At the point of an exception's stack-crawl it is too late because we cannot tolerate a GC.
        // See PossiblyUnwrapThrowable and its callers.
        _ASSERTE(GetLoadedModule() == GetDomainAssembly()->GetLoadedAssembly()->GetManifestModule());
        GetLoadedModule()->IsRuntimeWrapExceptions();
    }

    // Now activate any dependencies.
    // This will typically cause reentrancy of course.

#ifndef CROSSGEN_COMPILE

    //
    // Now call the module constructor.  Note that this might cause reentrancy;
    // this is fine and will be handled by the class cctor mechanism.
    //

    MethodTable *pMT = m_pModule->GetGlobalMethodTable();
    if (pMT != NULL)
    {
        pMT->CheckRestore();
        m_bDisableActivationCheck=TRUE;
        pMT->CheckRunClassInitThrowing();
    }
#ifdef _DEBUG
    if (g_pConfig->ExpandModulesOnLoad())
    {
        m_pModule->ExpandAll();
    }
#endif //_DEBUG

#endif // CROSSGEN_COMPILE

    RETURN;
}

#ifdef FEATURE_PREJIT
DomainFile *DomainFile::FindNextDomainFileWithNativeImage()
{
    LIMITED_METHOD_CONTRACT;
    return m_pNextDomainFileWithNativeImage;
}

void DomainFile::InsertIntoDomainFileWithNativeImageList()
{
    LIMITED_METHOD_CONTRACT;

    while (true)
    {
        DomainFile *pLastDomainFileFoundWithNativeImage = m_pDomain->m_pDomainFileWithNativeImageList;
        m_pNextDomainFileWithNativeImage = pLastDomainFileFoundWithNativeImage;
        if (pLastDomainFileFoundWithNativeImage == InterlockedCompareExchangeT(&m_pDomain->m_pDomainFileWithNativeImageList, this, pLastDomainFileFoundWithNativeImage))
            break;
    }
}
#endif

//--------------------------------------------------------------------------------
// DomainAssembly
//--------------------------------------------------------------------------------

DomainAssembly::DomainAssembly(AppDomain *pDomain, PEFile *pFile, LoaderAllocator *pLoaderAllocator)
  : DomainFile(pDomain, pFile),
    m_pAssembly(NULL),
    m_debuggerFlags(DACF_NONE),
    m_fDebuggerUnloadStarted(FALSE),
    m_fCollectible(pLoaderAllocator->IsCollectible()),
    m_fHostAssemblyPublished(false),
    m_pLoaderAllocator(pLoaderAllocator),
    m_NextDomainAssemblyInSameALC(NULL)
{
    CONTRACTL
    {
        CONSTRUCTOR_CHECK;
        STANDARD_VM_CHECK;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    pFile->ValidateForExecution();

    // !!! backout

    m_hExposedAssemblyObject = NULL;

    SetupDebuggingConfig();

    // Add a Module iterator entry for this assembly.
    IfFailThrow(m_Modules.Append(this));
}

DomainAssembly::~DomainAssembly()
{
    CONTRACTL
    {
        DESTRUCTOR_CHECK;
        NOTHROW;
        GC_TRIGGERS;
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    if (m_fHostAssemblyPublished)
    {
        // Remove association first.
        GetAppDomain()->UnPublishHostedAssembly(this);
    }

    ModuleIterator i = IterateModules(kModIterIncludeLoading);
    while (i.Next())
    {
        if (i.GetDomainFile() != this)
            delete i.GetDomainFile();
    }

    if (m_pAssembly != NULL)
    {
        delete m_pAssembly;
    }
}

void DomainAssembly::SetAssembly(Assembly* pAssembly)
{
    STANDARD_VM_CONTRACT;

    UpdatePEFile(pAssembly->GetManifestFile());
    _ASSERTE(pAssembly->GetManifestModule()->GetFile()==m_pFile);
    m_pAssembly = pAssembly;
    m_pModule = pAssembly->GetManifestModule();

    pAssembly->SetDomainAssembly(this);
}


#ifndef CROSSGEN_COMPILE
//---------------------------------------------------------------------------------------
//
// Returns managed representation of the assembly (Assembly or AssemblyBuilder).
// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
//
OBJECTREF DomainAssembly::GetExposedAssemblyObject()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        MODE_COOPERATIVE;
        GC_TRIGGERS;
    }
    CONTRACTL_END;

    LoaderAllocator * pLoaderAllocator = GetLoaderAllocator();

    if (!pLoaderAllocator->IsManagedScoutAlive())
    {   // We already collected the managed scout, so we cannot re-create any managed objects
        // Note: This is an optimization, as the managed scout can be collected right after this check
        return NULL;
    }

    if (m_hExposedAssemblyObject == NULL)
    {
        // Atomically create a handle

        LOADERHANDLE handle = pLoaderAllocator->AllocateHandle(NULL);

        FastInterlockCompareExchangePointer(&m_hExposedAssemblyObject, handle, static_cast<LOADERHANDLE>(NULL));
    }

    if (pLoaderAllocator->GetHandleValue(m_hExposedAssemblyObject) == NULL)
    {
        ASSEMBLYREF   assemblyObj = NULL;
        MethodTable * pMT;
        if (GetFile()->IsDynamic())
        {
            // This is unnecessary because the managed InternalAssemblyBuilder object
            // should have already been created at the time of DefineDynamicAssembly
            OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
            pMT = MscorlibBinder::GetClass(CLASS__INTERNAL_ASSEMBLY_BUILDER);
        }
        else
        {
            OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
            pMT = MscorlibBinder::GetClass(CLASS__ASSEMBLY);
        }

        // Will be TRUE only if LoaderAllocator managed object was already collected and therefore we should
        // return NULL
        BOOL fIsLoaderAllocatorCollected = FALSE;

        // Create the assembly object
        GCPROTECT_BEGIN(assemblyObj);
        assemblyObj = (ASSEMBLYREF)AllocateObject(pMT);

        assemblyObj->SetAssembly(this);

        // Attach the reference to the assembly to keep the LoaderAllocator for this collectible type
        // alive as long as a reference to the assembly is kept alive.
        // Currently we overload the sync root field of the assembly to do so, but the overload is not necessary.
        if (GetAssembly() != NULL)
        {
            OBJECTREF refLA = GetAssembly()->GetLoaderAllocator()->GetExposedObject();
            if ((refLA == NULL) && GetAssembly()->GetLoaderAllocator()->IsCollectible())
            {   // The managed LoaderAllocator object was collected
                fIsLoaderAllocatorCollected = TRUE;
            }
            assemblyObj->SetSyncRoot(refLA);
        }

        if (!fIsLoaderAllocatorCollected)
        {   // We should not expose this value in case the LoaderAllocator managed object was already
            // collected
            pLoaderAllocator->CompareExchangeValueInHandle(m_hExposedAssemblyObject, (OBJECTREF)assemblyObj, NULL);
        }
        GCPROTECT_END();

        if (fIsLoaderAllocatorCollected)
        {   // The LoaderAllocator managed object was already collected, we cannot re-create it
            // Note: We did not publish the allocated Assembly/AssmeblyBuilder object, it will get collected
            // by GC
            return NULL;
        }
    }

    return pLoaderAllocator->GetHandleValue(m_hExposedAssemblyObject);
} // DomainAssembly::GetExposedAssemblyObject
#endif // CROSSGEN_COMPILE

DomainFile* DomainAssembly::FindIJWModule(HMODULE hMod)
{
    CONTRACT (DomainFile*)
    {
        INSTANCE_CHECK;
        THROWS;
        GC_NOTRIGGER;
        MODE_ANY;
        POSTCONDITION(CheckPointer(RETVAL, NULL_OK));
    }
    CONTRACT_END;

    ModuleIterator i = IterateModules(kModIterIncludeLoaded);
    while (i.Next())
    {
        PEFile *pFile = i.GetDomainFile()->GetFile();

        if (   !pFile->IsResource()
            && !pFile->IsDynamic()
            && !pFile->IsILOnly()
            && pFile->GetIJWBase() == hMod)
        {
            RETURN i.GetDomainFile();
        }
    }
    RETURN NULL;
}


void DomainAssembly::Begin()
{
    STANDARD_VM_CONTRACT;

    {
        AppDomain::LoadLockHolder lock(m_pDomain);
        m_pDomain->AddAssembly(this);
    }
    // Make it possible to find this DomainAssembly object from associated ICLRPrivAssembly.
    GetAppDomain()->PublishHostedAssembly(this);
    m_fHostAssemblyPublished = true;
}

#ifdef FEATURE_PREJIT
void DomainAssembly::FindNativeImage()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

    ClearNativeImageStress();

    // We already have an image - we just need to do a few more checks

    if (GetFile()->HasNativeImage())
    {
#if defined(_DEBUG)
        if (g_pConfig->ForbidZap(GetSimpleName()))
        {
            SString sbuf;
            StackScratchBuffer scratch;
            sbuf.Printf(""COMPlus_NgenBind_ZapForbid violation: %s."", GetSimpleName());
            DbgAssertDialog(__FILE__, __LINE__, sbuf.GetUTF8(scratch));
        }
#endif

        ReleaseHolder<PEImage> pNativeImage = GetFile()->GetNativeImageWithRef();

        if (!CheckZapDependencyIdentities(pNativeImage))
        {
            m_dwReasonForRejectingNativeImage = ReasonForRejectingNativeImage_DependencyIdentityMismatch;
            STRESS_LOG2(LF_ZAP,LL_INFO100,""Rejecting native file %p, because dependency identity mismatch - reason 0x%x\\n"",pNativeImage.GetValue(),m_dwReasonForRejectingNativeImage);
            ExternalLog(LL_ERROR, ""Rejecting native image because of identity mismatch ""
                ""with one or more of its assembly dependencies. The assembly needs ""
                ""to be ngenned again"");

            GetFile()->ClearNativeImage();

            // Always throw exceptions when we throw the NI out
            ThrowHR(CLR_E_BIND_NI_DEP_IDENTITY_MISMATCH);
        }
        else
        {
            Module *  pNativeModule = pNativeImage->GetLoadedLayout()->GetPersistedModuleImage();
            PEFile ** ppNativeFile = (PEFile **) (PBYTE(pNativeModule) + Module::GetFileOffset());

            PEAssembly * pFile = (PEAssembly *)FastInterlockCompareExchangePointer((void **)ppNativeFile, (void *)GetFile(), (void *)NULL);
            STRESS_LOG3(LF_ZAP,LL_INFO100,""Attempted to set  new native file %p, old file was %p, location in the image=%p\\n"",GetFile(),pFile,ppNativeFile);
            if (pFile!=NULL)
            {
                // The non-shareable native image has already been used in this process by another Module.
                // We have to abandon the native image.  (Note that it isn't enough to
                // just abandon the preload image, since the code in the file will
                // reference the image directly).
                m_dwReasonForRejectingNativeImage = ReasonForRejectingNativeImage_CannotShareNiAssemblyNotDomainNeutral;
                STRESS_LOG3(LF_ZAP,LL_INFO100,""Rejecting native file %p, because it is already used by file %p - reason 0x%x\\n"",GetFile(),pFile,m_dwReasonForRejectingNativeImage);

                ExternalLog(LL_WARNING, ""ZAP: An ngen image of an assembly which ""
                    ""is not loaded as domain-neutral cannot be used in multiple appdomains ""
                    ""- abandoning ngen image. The assembly will be JIT-compiled in ""
                    ""the second appdomain. See System.LoaderOptimization.MultiDomain ""
                    ""for information about domain-neutral loading."");
                GetFile()->ClearNativeImage();
            }
            else
            {
                GetFile()->AddRef();

                LOG((LF_ZAP, LL_INFO100, ""ZAP: Found a candidate native image for %s\\n"", GetSimpleName()));
            }
        }
    }

    if (!GetFile()->HasNativeImage())
    {
        //
        // Verify that the IL image is consistent with the NGen images loaded into appdomain
        //

        AssemblySpec spec;
        spec.InitializeSpec(GetFile());

        GUID mvid;
        GetFile()->GetMVID(&mvid);

        GetAppDomain()->CheckForMismatchedNativeImages(&spec, &mvid);
    }

    CheckZapRequired();
}
#endif // FEATURE_PREJIT

void DomainAssembly::Allocate()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    AllocMemTracker   amTracker;
    AllocMemTracker * pamTracker = &amTracker;

    Assembly * pAssembly = m_pAssembly;

    if (pAssembly==NULL)
    {
        //! If you decide to remove ""if"" do not remove this brace: order is important here - in the case of an exception,
        //! the Assembly holder must destruct before the AllocMemTracker declared above.

        // We can now rely on the fact that our MDImport will not change so we can stop refcounting it.
        GetFile()->MakeMDImportPersistent();

        NewHolder<Assembly> assemblyHolder(NULL);

        assemblyHolder = pAssembly = Assembly::Create(m_pDomain, GetFile(), GetDebuggerInfoBits(), this->IsCollectible(), pamTracker, this->IsCollectible() ? this->GetLoaderAllocator() : NULL);
        assemblyHolder->SetIsTenured();

        //@todo! This is too early to be calling SuppressRelease. The right place to call it is below after
        // the CANNOTTHROWCOMPLUSEXCEPTION. Right now, we have to do this to unblock OOM injection testing quickly
        // as doing the right thing is nontrivial.
        pamTracker->SuppressRelease();
        assemblyHolder.SuppressRelease();
    }

#ifdef FEATURE_COMINTEROP
    // If we are in an AppX process we should prevent loading of PIA in the AppDomain.
    // This will ensure that we do not run into any compatibility issues in case a type has both a co-Class and a Winrt Class
    if (AppX::IsAppXProcess() && pAssembly->IsPIA())
    {
        COMPlusThrow(kNotSupportedException, W(""NotSupported_PIAInAppxProcess""));
    }
#endif

    SetAssembly(pAssembly);

#ifdef FEATURE_PREJIT
    BOOL fInsertIntoAssemblySpecBindingCache = TRUE;

    // Insert AssemblyDef details into AssemblySpecBindingCache if appropriate


    fInsertIntoAssemblySpecBindingCache = fInsertIntoAssemblySpecBindingCache && GetFile()->CanUseWithBindingCache();

    if (fInsertIntoAssemblySpecBindingCache)
    {
        AssemblySpec specAssemblyDef;
        specAssemblyDef.InitializeSpec(GetFile());
        if (specAssemblyDef.IsStrongNamed() && specAssemblyDef.HasPublicKey())
        {
            specAssemblyDef.ConvertPublicKeyToToken();
        }
        m_pDomain->AddAssemblyToCache(&specAssemblyDef, this);
    }
#endif
} // DomainAssembly::Allocate

void DomainAssembly::DeliverAsyncEvents()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        NOTHROW;
        GC_TRIGGERS;
        MODE_ANY;
    }
    CONTRACTL_END;

    OVERRIDE_LOAD_LEVEL_LIMIT(FILE_ACTIVE);
    m_pDomain->RaiseLoadingAssemblyEvent(this);

}


void DomainAssembly::DeliverSyncEvents()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

    GetCurrentModule()->NotifyEtwLoadFinished(S_OK);

    // We may be notified from inside the loader lock if we are delivering IJW events, so keep track.
#ifdef PROFILING_SUPPORTED
    if (!IsProfilerNotified())
    {
        SetProfilerNotified();
        GetCurrentModule()->NotifyProfilerLoadFinished(S_OK);
    }

#endif
#ifdef DEBUGGING_SUPPORTED
    GCX_COOP();
    if (!IsDebuggerNotified())
    {
        SetShouldNotifyDebugger();

        // Still work to do even if no debugger is attached.
        NotifyDebuggerLoad(ATTACH_ASSEMBLY_LOAD, FALSE);

    }
#endif // DEBUGGING_SUPPORTED
} // DomainAssembly::DeliverSyncEvents

/*
  // The enum for dwLocation from managed code:
    public enum ResourceLocation
    {
        Embedded = 1,
        ContainedInAnotherAssembly = 2,
        ContainedInManifestFile = 4
    }
*/

BOOL DomainAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
                                 PBYTE *pbInMemoryResource, DomainAssembly** pAssemblyRef,
                                 LPCSTR *szFileName, DWORD *dwLocation,
                                 BOOL fSkipRaiseResolveEvent)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    return GetFile()->GetResource( szName,
                                   cbResource,
                                   pbInMemoryResource,
                                   pAssemblyRef,
                                   szFileName,
                                   dwLocation,
                                   fSkipRaiseResolveEvent,
                                   this,
                                   this->m_pDomain );
}


#ifdef FEATURE_PREJIT

// --------------------------------------------------------------------------------
// Remember the timestamp of the CLR DLLs used to compile the ngen image.
// These will be checked at runtime by PEFile::CheckNativeImageTimeStamp().
//

void GetTimeStampsForNativeImage(CORCOMPILE_VERSION_INFO * pNativeVersionInfo)
{
    CONTRACTL
    {
        STANDARD_VM_CHECK;
        PRECONDITION(::GetAppDomain()->IsCompilationDomain());
    }
    CONTRACTL_END;

    // Do not store runtime timestamps into NGen image for cross-platform NGen determinism
}

//
// Which processor should ngen target?
// This is needed when ngen wants to target for ""reach"" if the ngen images will be
// used on other machines (the Operating System or the OEM build lab can do this).
// It can also be used to reduce the testing matrix
//
void GetNGenCpuInfo(CORINFO_CPU * cpuInfo)
{
    LIMITED_METHOD_CONTRACT;

#ifdef TARGET_X86

    static CORINFO_CPU ngenCpuInfo =
        {
            (CPU_X86_PENTIUM_PRO << 8), // dwCPUType
            0x00000000,                 // dwFeatures
            0                           // dwExtendedFeatures
        };

    // We always generate P3-compatible code on CoreCLR
    *cpuInfo = ngenCpuInfo;

#else // TARGET_X86
    cpuInfo->dwCPUType = 0;
    cpuInfo->dwFeatures = 0;
    cpuInfo->dwExtendedFeatures = 0;
#endif // TARGET_X86
}

// --------------------------------------------------------------------------------

void DomainAssembly::GetCurrentVersionInfo(CORCOMPILE_VERSION_INFO *pNativeVersionInfo)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

    // Clear memory so that we won't write random data into the zapped file
    ZeroMemory(pNativeVersionInfo, sizeof(CORCOMPILE_VERSION_INFO));

    // Pick up any compilation directives for code flavor

    BOOL fForceDebug, fForceProfiling, fForceInstrument;
    SystemDomain::GetCompilationOverrides(&fForceDebug,
                                          &fForceProfiling,
                                          &fForceInstrument);

#ifndef TARGET_UNIX
    pNativeVersionInfo->wOSPlatformID = VER_PLATFORM_WIN32_NT;
#else
    pNativeVersionInfo->wOSPlatformID = VER_PLATFORM_UNIX;
#endif

    // The native images should be OS-version agnostic. Do not store the actual OS version for determinism.
    // pNativeVersionInfo->wOSMajorVersion = (WORD) osInfo.dwMajorVersion;
    pNativeVersionInfo->wOSMajorVersion = 4;

    pNativeVersionInfo->wMachine = IMAGE_FILE_MACHINE_NATIVE_NI;

    pNativeVersionInfo->wVersionMajor = CLR_MAJOR_VERSION;
    pNativeVersionInfo->wVersionMinor = CLR_MINOR_VERSION;
    pNativeVersionInfo->wVersionBuildNumber = CLR_BUILD_VERSION;
    pNativeVersionInfo->wVersionPrivateBuildNumber = CLR_BUILD_VERSION_QFE;

    GetNGenCpuInfo(&pNativeVersionInfo->cpuInfo);

#if _DEBUG
    pNativeVersionInfo->wBuild = CORCOMPILE_BUILD_CHECKED;
#else
    pNativeVersionInfo->wBuild = CORCOMPILE_BUILD_FREE;
#endif

#ifdef DEBUGGING_SUPPORTED
    if (fForceDebug || !CORDebuggerAllowJITOpts(GetDebuggerInfoBits()))
    {
        pNativeVersionInfo->wCodegenFlags |= CORCOMPILE_CODEGEN_DEBUGGING;
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_DEBUG;
    }
    else
#endif // DEBUGGING_SUPPORTED
    {
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_DEBUG_NONE;
    }

#if defined (PROFILING_SUPPORTED_DATA) || defined(PROFILING_SUPPORTED)
    if (fForceProfiling || CORProfilerUseProfileImages())
    {
        pNativeVersionInfo->wCodegenFlags |= CORCOMPILE_CODEGEN_PROFILING;
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_PROFILING;
#ifdef DEBUGGING_SUPPORTED
        // Note that we have hardwired profiling to also imply optimized debugging
        // info.  This cuts down on one permutation of prejit files.
        pNativeVersionInfo->wCodegenFlags &= ~CORCOMPILE_CODEGEN_DEBUGGING;
        pNativeVersionInfo->wConfigFlags &= ~(CORCOMPILE_CONFIG_DEBUG|
                                              CORCOMPILE_CONFIG_DEBUG_DEFAULT);
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_DEBUG_NONE;
#endif // DEBUGGING_SUPPORTED
    }
    else
#endif // PROFILING_SUPPORTED_DATA || PROFILING_SUPPORTED
    {
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_PROFILING_NONE;
    }

#ifdef DEBUGGING_SUPPORTED

    // Note the default assembly flags (from the custom attributes & INI file) , so we can
    // set determine whether or not the current settings
    // match the ""default"" setting or not.

    // Note that the INI file settings are considered a part of the
    // assembly, even though they could theoretically change between
    // ngen time and runtime.  It is just too expensive and awkward to
    // look up the INI file before binding to the native image at
    // runtime, so we effectively snapshot it at ngen time.

    DWORD defaultFlags = ComputeDebuggingConfig();

    if (CORDebuggerAllowJITOpts(defaultFlags))
    {
        // Default is optimized code
        if ((pNativeVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_DEBUGGING) == 0)
            pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_DEBUG_DEFAULT;
    }
    else
    {
        // Default is non-optimized debuggable code
        if ((pNativeVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_DEBUGGING) != 0)
            pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_DEBUG_DEFAULT;
    }

#endif // DEBUGGING_SUPPORTED

    if (fForceInstrument || GetAssembly()->IsInstrumented())
    {
        pNativeVersionInfo->wCodegenFlags |= CORCOMPILE_CODEGEN_PROF_INSTRUMENTING;
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_INSTRUMENTATION;
    }
    else
    {
        pNativeVersionInfo->wConfigFlags |= CORCOMPILE_CONFIG_INSTRUMENTATION_NONE;
    }


    GetTimeStampsForNativeImage(pNativeVersionInfo);

    // Store signature of source assembly.
    GetOptimizedIdentitySignature(&pNativeVersionInfo->sourceAssembly);

    // signature will is hash of the whole file. It is written by zapper.
    // IfFailThrow(CoCreateGuid(&pNativeVersionInfo->signature));
}

void DomainAssembly::GetOptimizedIdentitySignature(CORCOMPILE_ASSEMBLY_SIGNATURE *pSignature)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        GC_TRIGGERS;
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

    //
    // Write the MVID into the version header.
    //

    //
    // If this assembly has skip verification permission, then we store its
    // mvid.  If at load time the assembly still has skip verification
    // permission, then we can base the matches purely on mvid values and
    // skip the perf-heavy hashing of the file.
    //

    //
    // The reason that we tell IsFullyTrusted to do a quick check
    // only is because that allows us make a determination for the most
    // common full trust scenarios (local machine) without actually
    // resolving policy and bringing in a whole list of assembly
    // dependencies.
    //
    ReleaseHolder<IMDInternalImport> scope (GetFile()->GetMDImportWithRef());
    IfFailThrow(scope->GetScopeProps(NULL, &pSignature->mvid));

    // Use the NGen image if posssible. IL image does not even have to be present on CoreCLR.
    if (GetFile()->HasNativeImage())
    {
        PEImageHolder pNativeImage(GetFile()->GetNativeImageWithRef());

        CORCOMPILE_VERSION_INFO* pVersionInfo = pNativeImage->GetLoadedLayout()->GetNativeVersionInfo();
        pSignature->timeStamp = pVersionInfo->sourceAssembly.timeStamp;
        pSignature->ilImageSize = pVersionInfo->sourceAssembly.ilImageSize;

        return;
    }

    // Write the time stamp
    PEImageLayoutHolder ilLayout(GetFile()->GetAnyILWithRef());
    pSignature->timeStamp = ilLayout->GetTimeDateStamp();
    pSignature->ilImageSize = ilLayout->GetVirtualSize();
}

BOOL DomainAssembly::CheckZapDependencyIdentities(PEImage *pNativeImage)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        STANDARD_VM_CHECK;
    }
    CONTRACTL_END;

    AssemblySpec spec;
    spec.InitializeSpec(this->GetFile());

    // The assembly spec should have the binding context associated with it
    _ASSERTE(spec.GetBindingContext()  || spec.IsAssemblySpecForMscorlib());

    CORCOMPILE_VERSION_INFO *pVersionInfo = pNativeImage->GetLoadedLayout()->GetNativeVersionInfo();

    // Check our own assembly first
    GetAppDomain()->CheckForMismatchedNativeImages(&spec, &pVersionInfo->sourceAssembly.mvid);

    // Check MVID in metadata against MVID in CORCOMPILE_VERSION_INFO - important when metadata is loaded from IL instead of NI
    ReleaseHolder<IMDInternalImport> pImport(this->GetFile()->GetMDImportWithRef());
    GUID mvid;
    IfFailThrow(pImport->GetScopeProps(NULL, &mvid));
    GetAppDomain()->CheckForMismatchedNativeImages(&spec, &mvid);

    // Now Check dependencies
    COUNT_T cDependencies;
    CORCOMPILE_DEPENDENCY *pDependencies = pNativeImage->GetLoadedLayout()->GetNativeDependencies(&cDependencies);
    CORCOMPILE_DEPENDENCY *pDependenciesEnd = pDependencies + cDependencies;

    while (pDependencies < pDependenciesEnd)
    {
        if (pDependencies->dwAssemblyDef != mdAssemblyRefNil)
        {
            AssemblySpec name;
            name.InitializeSpec(pDependencies->dwAssemblyDef, pNativeImage->GetNativeMDImport(), this);

            if (!name.IsAssemblySpecForMscorlib())
            {
                // We just initialized the assembly spec for the NI dependency. This will not have binding context
                // associated with it, so set it from that of the parent.
                _ASSERTE(!name.GetBindingContext());
                ICLRPrivBinder *pParentAssemblyBindingContext = name.GetBindingContextFromParentAssembly(name.GetAppDomain());
                _ASSERTE(pParentAssemblyBindingContext);
                name.SetBindingContext(pParentAssemblyBindingContext);
            }

            GetAppDomain()->CheckForMismatchedNativeImages(&name, &pDependencies->signAssemblyDef.mvid);
        }

        pDependencies++;
    }

    return TRUE;
}
#endif // FEATURE_PREJIT





// <TODO>@todo Find a better place for these</TODO>
#define DE_CUSTOM_VALUE_NAMESPACE        ""System.Diagnostics""
#define DE_DEBUGGABLE_ATTRIBUTE_NAME     ""DebuggableAttribute""

// <TODO>@todo .INI file is a temporary workaround for Beta 1</TODO>
#define DE_INI_FILE_SECTION_NAME          W("".NET Framework Debugging Control"")
#define DE_INI_FILE_KEY_TRACK_INFO        W(""GenerateTrackingInfo"")
#define DE_INI_FILE_KEY_ALLOW_JIT_OPTS    W(""AllowOptimize"")

DWORD DomainAssembly::ComputeDebuggingConfig()
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        WRAPPER(GC_TRIGGERS);
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

#ifdef DEBUGGING_SUPPORTED
    DWORD dacfFlags = DACF_ALLOW_JIT_OPTS;

    if (GetDebuggingOverrides(&dacfFlags))
    {
        dacfFlags |= DACF_USER_OVERRIDE;
    }
    else
    {
        IfFailThrow(GetDebuggingCustomAttributes(&dacfFlags));
    }

    return dacfFlags;
#else // !DEBUGGING_SUPPORTED
    return 0;
#endif // DEBUGGING_SUPPORTED
}

void DomainAssembly::SetupDebuggingConfig(void)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        WRAPPER(GC_TRIGGERS);
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

#ifdef DEBUGGING_SUPPORTED
    DWORD dacfFlags = ComputeDebuggingConfig();

    SetDebuggerInfoBits((DebuggerAssemblyControlFlags)dacfFlags);

    LOG((LF_CORDB, LL_INFO10, ""Assembly %S: bits=0x%x\\n"", GetDebugName(), GetDebuggerInfoBits()));
#endif // DEBUGGING_SUPPORTED
}

// The format for the (temporary) .INI file is:

// [.NET Framework Debugging Control]
// GenerateTrackingInfo=<n> where n is 0 or 1
// AllowOptimize=<n> where n is 0 or 1

// Where neither x nor y equal INVALID_INI_INT:
#define INVALID_INI_INT (0xFFFF)

bool DomainAssembly::GetDebuggingOverrides(DWORD *pdwFlags)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        THROWS;
        GC_NOTRIGGER;
        MODE_ANY;
        INJECT_FAULT(COMPlusThrowOM(););
    }
    CONTRACTL_END;

#if defined(DEBUGGING_SUPPORTED) && !defined(FEATURE_CORESYSTEM)
    // TODO FIX in V5.0
    // Any touch of the file system is relatively expensive even in the warm case.
    //
    // Ideally we remove the .INI feature completely (if we need something put it in the .exe.config file)
    //
    // However because of compatibility concerns, we won't do this until the next side-by-side release
    // In the mean time don't check in the case where we have already loaded the NGEN image, as the
    // JIT overrides don't mean anything in that case as we won't be jitting anyway.
    // This avoids doing these probes for framework DLLs right away.
    if (GetFile()->HasNativeImage())
        return false;

    _ASSERTE(pdwFlags);

    bool fHasBits = false;
    WCHAR *pFileName = NULL;
    HRESULT hr = S_OK;
    UINT cbExtOrValue = 4;
    WCHAR *pTail = NULL;
    size_t len = 0;
    WCHAR *lpFileName = NULL;

    const WCHAR *wszFileName = GetFile()->GetPath();

    if (wszFileName == NULL)
    {
        return false;
    }

    // lpFileName is a copy of the original, and will be edited.
    CQuickBytes qb;
    len = wcslen(wszFileName);
    size_t cchlpFileName = (len + 1);
    lpFileName = (WCHAR*)qb.AllocThrows(cchlpFileName * sizeof(WCHAR));
    wcscpy_s(lpFileName, cchlpFileName, wszFileName);

    pFileName = wcsrchr(lpFileName, W('\\\\'));

    if (pFileName == NULL)
    {
        pFileName = lpFileName;
    }

    if (*pFileName == W('\\\\'))
    {
        pFileName++; //move the pointer past the last '\\'
    }

    _ASSERTE(wcslen(W("".INI"")) == cbExtOrValue);

    if (pFileName == NULL || (pTail=wcsrchr(pFileName, W('.'))) == NULL || (wcslen(pTail)<cbExtOrValue))
    {
        return false;
    }

    wcscpy_s(pTail, cchlpFileName - (pTail - lpFileName), W("".INI""));

    // Win2K has a problem if multiple processes call GetPrivateProfile* on the same
    // non-existent .INI file simultaneously.  The OS livelocks in the kernel (i.e.
    // outside of user space) and remains there at full CPU for several minutes.  Then
    // it breaks out.  Here is our work-around, while we pursue a fix in a future
    // version of the OS.
    if (WszGetFileAttributes(lpFileName) == INVALID_FILE_ATTRIBUTES)
        return false;

    // Having modified the filename, we use the full path
    // to actually get the file.
    if ((cbExtOrValue=WszGetPrivateProfileInt(DE_INI_FILE_SECTION_NAME,
                                              DE_INI_FILE_KEY_TRACK_INFO,
                                              INVALID_INI_INT,
                                              lpFileName)) != INVALID_INI_INT)
    {
        if (cbExtOrValue != 0)
        {
            *pdwFlags |= DACF_OBSOLETE_TRACK_JIT_INFO;
        }
        else
        {
            *pdwFlags &= (~DACF_OBSOLETE_TRACK_JIT_INFO);
        }

        fHasBits = true;
    }

    if ((cbExtOrValue=WszGetPrivateProfileInt(DE_INI_FILE_SECTION_NAME,
                                              DE_INI_FILE_KEY_ALLOW_JIT_OPTS,
                                              INVALID_INI_INT,
                                              lpFileName)) != INVALID_INI_INT)
    {
        if (cbExtOrValue != 0)
        {
            *pdwFlags |= DACF_ALLOW_JIT_OPTS;
        }
        else
        {
            *pdwFlags &= (~DACF_ALLOW_JIT_OPTS);
        }

        fHasBits = true;
    }

    return fHasBits;

#else  // DEBUGGING_SUPPORTED && !FEATURE_CORESYSTEM
    return false;
#endif // DEBUGGING_SUPPORTED && !FEATURE_CORESYSTEM
}


// For right now, we only check to see if the DebuggableAttribute is present - later may add fields/properties to the
// attributes.
HRESULT DomainAssembly::GetDebuggingCustomAttributes(DWORD *pdwFlags)
{
    CONTRACTL
    {
        INSTANCE_CHECK;
        NOTHROW;
        WRAPPER(GC_TRIGGERS);
        MODE_ANY;
        FORBID_FAULT;
        PRECONDITION(CheckPointer(pdwFlags));
    }
    CONTRACTL_END;

    HRESULT hr = S_OK;

#ifdef FEATURE_PREJIT
    ReleaseHolder<PEImage> pNativeImage=GetFile()->GetNativeImageWithRef();
    if (pNativeImage)
    {
        CORCOMPILE_VERSION_INFO * pVersion = pNativeImage->GetLoadedLayout()->GetNativeVersionInfo();
        PREFIX_ASSUME(pVersion != NULL);

        WORD codegen = pVersion->wCodegenFlags;

        if (codegen & CORCOMPILE_CODEGEN_DEBUGGING)
        {
            *pdwFlags &= (~DACF_ALLOW_JIT_OPTS);
        }
        else
        {
            *pdwFlags |= DACF_ALLOW_JIT_OPTS;
        }

    }
    else
#endif // FEATURE_PREJIT
    {
        ULONG size;
        BYTE *blob;
        mdModule mdMod;
        ReleaseHolder<IMDInternalImport> mdImport(GetFile()->GetMDImportWithRef());
        mdMod = mdImport->GetModuleFromScope();
        mdAssembly asTK = TokenFromRid(mdtAssembly, 1);

        hr = mdImport->GetCustomAttributeByName(asTK,
                                                DE_CUSTOM_VALUE_NAMESPACE
                                                NAMESPACE_SEPARATOR_STR
                                                DE_DEBUGGABLE_ATTRIBUTE_NAME,
                                                (const void**)&blob,
                                                &size);

        // If there is no custom value, then there is no entrypoint defined.
        if (!(FAILED(hr) || hr == S_FALSE))
        {
            // We're expecting a 6 or 8 byte blob:
            //
            // 1, 0, enable tracking, disable opts, 0, 0
            if ((size == 6) || (size == 8))
            {
                if (!((blob[0] == 1) && (blob[1] == 0)))
                {
                    BAD_FORMAT_NOTHROW_ASSERT(!""Invalid blob format for custom attribute"");
                    return COR_E_BADIMAGEFORMAT;
                }

                if (blob[2] & 0x1)
                {
                    *pdwFlags |= DACF_OBSOLETE_TRACK_JIT_INFO;
                }
                else
                {
                    *pdwFlags &= (~DACF_OBSOLETE_TRACK_JIT_INFO);
                }

                if (blob[2] & 0x2)
                {
                    *pdwFlags |= DACF_IGNORE_PDBS;
                }
                else
                {
                    *pdwFlags &= (~DACF_IGNORE_PDBS);
                }


                // For compatibility, we enable optimizations if the tracking byte is zero,
                // even if disable opts is nonzero
                if (((blob[2] & 0x1) == 0) || (blob[3] == 0))
                {
                    *pdwFlags |= DACF_ALLOW_JIT_OPTS;
                }
                else
                {
                    *pdwFlags &= (~DACF_ALLOW_JIT_OPTS);
                }

                LOG((LF_CORDB, LL_INFO10, ""Assembly %S: has %s=%d,%d bits = 0x%x\\n"", GetDebugName(),
                     DE_DEBUGGABLE_ATTRIBUTE_NAME,
                     blob[2], blob[3], *pdwFlags));
            }
        }
    }

    return hr;
}

BOOL DomainAssembly::NotifyDebuggerLoad(int flags, BOOL attaching)
{
    WRAPPER_NO_CONTRACT;

    BOOL result = FALSE;

    if (!IsVisibleToDebugger())
        return FALSE;

    // Debugger Attach is done totally out-of-process. Does not call code in-proc.
    _ASSERTE(!attaching);

    // Make sure the debugger has been initialized.  See code:Debugger::Startup.
    if (g_pDebugInterface == NULL)
    {
        _ASSERTE(!CORDebuggerAttached());
        return FALSE;
    }

    // There is still work we need to do even when no debugger is attached.

    if (flags & ATTACH_ASSEMBLY_LOAD)
    {
        if (ShouldNotifyDebugger())
        {
            g_pDebugInterface->LoadAssembly(this);
        }
        result = TRUE;
    }

    DomainModuleIterator i = IterateModules(kModIterIncludeLoading);
    while (i.Next())
    {
        DomainFile * pDomainFile = i.GetDomainFile();
        if(pDomainFile->ShouldNotifyDebugger())
        {
            result = result ||
                pDomainFile->GetModule()->NotifyDebuggerLoad(this->GetAppDomain(), pDomainFile, flags, attaching);
        }
    }
    if( ShouldNotifyDebugger())
    {
           result|=m_pModule->NotifyDebuggerLoad(m_pDomain, this, ATTACH_MODULE_LOAD, attaching);
           SetDebuggerNotified();
    }



    return result;
}

void DomainAssembly::NotifyDebuggerUnload()
{
    LIMITED_METHOD_CONTRACT;

    if (!IsVisibleToDebugger())
        return;

    if (!this->GetAppDomain()->IsDebuggerAttached())
        return;

    m_fDebuggerUnloadStarted = TRUE;

    // Dispatch module unloads for all modules. Debugger is resilient in case we haven't dispatched
    // a previous load event (such as if debugger attached after the modules was loaded).
    DomainModuleIterator i = IterateModules(kModIterIncludeLoading);
    while (i.Next())
    {
            i.GetDomainFile()->GetModule()->NotifyDebuggerUnload(this->GetAppDomain());
    }

    g_pDebugInterface->UnloadAssembly(this);

}

#endif // #ifndef DACCESS_COMPILE

#ifdef DACCESS_COMPILE

void
DomainFile::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
{
    SUPPORTS_DAC;

    //sizeof(DomainFile) == 0x60
    DAC_ENUM_VTHIS();

    // Modules are needed for all minidumps, but they are enumerated elsewhere
    // so we don't need to duplicate effort; thus we do noting with m_pModule.

    // For MiniDumpNormal, we only want the file name.
    if (m_pFile.IsValid())
    {
        m_pFile->EnumMemoryRegions(flags);
    }

    if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE
    && m_pDomain.IsValid())
    {
        m_pDomain->EnumMemoryRegions(flags, true);
    }
}

void
DomainAssembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
{
    SUPPORTS_DAC;

    //sizeof(DomainAssembly) == 0xe0
    DAC_ENUM_VTHIS();
    DomainFile::EnumMemoryRegions(flags);

    // For minidumps without full memory, we need to always be able to iterate over m_Modules.
    m_Modules.EnumMemoryRegions(flags);

    if (flags != CLRDATA_ENUM_MEM_MINI && flags != CLRDATA_ENUM_MEM_TRIAGE)
    {
        if (m_pAssembly.IsValid())
        {
            m_pAssembly->EnumMemoryRegions(flags);
        }
    }
}

#endif // #ifdef DACCESS_COMPILE
",16375,True,2978.437430217361,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.19.0]]
==== 1.19.0 - YYYY/MM/DD

[float]
===== Breaking changes

[float]
===== Features

[float]
===== Bug fixes

[[release-notes-1.x]]
=== Java Agent version 1.x

[[release-notes-1.18.0]]
==== 1.18.0 - 2020/09/08

[float]
===== Features
* 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]
* Add `profiling_inferred_spans_lib_directory` option to override the default temp directory used for exporting the async-profiler library.
  This is useful for server-hardened environments where `/tmp` is often configured with `noexec`, leading to `java.lang.UnsatisfiedLinkError` errors - {pull}1350[#1350]
* Create spans for Servlet dispatches to FORWARD, INCLUDE and ERROR - {pull}1212[#1212]
* Support JDK 11 HTTPClient - {pull}1307[#1307]
* Lazily create profiler temporary files {pull}1360[#1360]
* Convert the followings to Indy Plugins (see details in <<release-notes-1.18.0.rc1, 1.18.0-rc1 relase notes>>): gRPC,
  AsyncHttpClient, Apache HttpClient
* The agent now collects cgroup memory metrics (see details in <<metrics-cgroup,Metrics page>>)
* Update async-profiler to 1.8.1 {pull}1382[#1382]

[float]
===== Bug fixes
* 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]
* Fix remote attach 'jps' executable not found when 'java' binary is symlinked ot a JRE - {pull}1352[#1352]

[[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.
",12081,True,2579.089807516075,median
"= Morpheus - Developer Guide
:site-section: DeveloperGuide
:toc:
:toc-title:
:toc-placement: preamble
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
:experimental:
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:warning-caption: :warning:
endif::[]
:repoURL: https://github.com/AY1920S2-CS2103T-W13-2/main/tree/master

By: `AY1920S2-CS2103T-W13-2`      Since: `Feb 2020`      Licence: `MIT`

//tag::introduction[]
== Introduction
=== Product Description (Hui Ming)

Morpheus is a desktop application that aims to facilitate the administrative work of hotel services as a hotel room management system.
The system will also provide statistics and reports, constructed from the analysis of the details in the user-provided database.
Most of the user interaction occurs via a CLI (Command Line Interface).

.Morpheus UI
image::Ui.png[]

=== Purpose (Hui Ming)

This *Developer Guide* describes the architecture and software design of Morpheus.
The intended audience is the *developers, designers and software testers* who wish to understand, maintain & upgrade the desktop application.
//end::introduction[]

=== How to navigate this document
* _This section shows you how to read and understand this document._

** Any text in `markup` suggests that you may enter it as a command in the app.

** A link like link:{repoURL}[this] will take you to the link destination when clicked.

** kbd:[Keyboard] shows that this is a key that can be pressed on the keyboard.

TIP: This is a useful tip to help optimize your experience using Morpheus.

NOTE: This is important information you need to take note of!

== Setting up

Refer to the guide <<SettingUp#, here>>.

== Design
//tag::Architecture[]
[[Design-Architecture]]
=== Architecture (Sanchari)

.Architecture Diagram
image::OverallArchitecture.png[]

The *_Architecture Diagram_* given above explains the high-level design of the App.

*Morpheus* closely follows the **Command Pattern ** design of software. +
This is a quick representation of how the Command Pattern works: +
_Client -> Invoker -> CommandQueue -> ExecuteCommand_

In this case, the client is the application which creates and adds a command object to the invoker.
The invoker then executes the command objects.
//end::Architecture[]

Given below is a quick overview of the components in the architecture of the software.

<<Design-Main,*`Main`*>> has two classes called link:{repoURL}/src/main/java/seedu/address/Main.java[`Main`] and link:{repoURL}/src/main/java/seedu/address/MainApp.java[`MainApp`]. It is responsible for:

* At app launch: Initializes the components in the correct sequence, and connects them up with each other.
* At shut down: Shuts down the components and invokes cleanup method where necessary.

<<Design-Commons,*`Commons`*>> represents a collection of classes used by multiple other components.
The following class plays an important role at the architecture level:

* `LogsCenter` : Used by many classes to write log messages to the App's log file.

<<Design-Ui,*`UI`*>>: The UI of the App.

* Presents App data in a GUI.
* Receives commands from the user.

<<Design-Logic,*`Logic`*>>: The command executor.

* Parses the commands entered by user.
* Adds command objects to command queue.

<<Design-Model,*`Model`*>>: Holds the data of the App in-memory.

* Executes actions indicated by commands on the data in-memory.

<<Design-Storage,*`Storage`*>>: Reads data from, and writes data to, the hard disk.

Each of the four components

* Defines its _API_ in an `interface` with the same name as the Component.
* Exposes its functionality using a `{Component Name}Manager` class.

[discrete]
==== How the architecture components interact with each other

The _Sequence Diagram_ below shows an overview how the components interact with each other for the scenario where the user issues the command `deleteroom`.

.Component interactions for `deleteroom` command
image::ArchitectureComponentDiagram.png[]

The sections below give more details of each component.

[[Design-Ui]]

//tag::UiCompJohnny[]
=== UI component

.Structure of the UI Component
image::UiDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/address/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `RoomListPanel`, `PersonListPanel`, `WelcomePanel` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class.

The `UI` component uses JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files that are in the `src/main/resources/view` folder. For example, the layout of the link:{repoURL}/src/main/java/seedu/address/ui/MainWindow.java[`MainWindow`] is specified in link:{repoURL}/src/main/resources/view/MainWindow.fxml[`MainWindow.fxml`]

The `UI` component,

* Executes user commands using the `Logic` component.
* Listens for changes to `Model` data so that the UI can be updated with the modified data.

* Receive command result to change view accordingly.

Below is diagram for how UI extract command result for changing view.

.Command work flow for MainWindow
image::commandSwitchUi.png[]

//end::UiCompJohnny[]
[[Design-Logic]]
=== Logic component

[[fig-LogicClassDiagram]]
.Structure of the Logic Component
image::LogicClassDiagram.png[]

*API* :
link:{repoURL}/src/main/java/seedu/address/logic/Logic.java[`Logic.java`]

.  `Logic` uses the `AddressBookParser` class to parse the user command.
.  This results in a `Command` object which is executed by the `LogicManager`.
.  The command execution can affect the `Model` (e.g. adding a room).
.  The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
.  In addition, the `CommandResult` object can also instruct the `Ui` to perform certain actions, such as displaying help to the user.

Given below is the Sequence Diagram for interactions within the `Logic` component for the `execute(""deleteroom"")` API call.

.Interactions Inside the Logic Component for the `deleteroom` Command
image::LogicSequenceDiagram.png[]


[[Design-Model]]
=== Model component

.Structure of the Model Component
image::ModelDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/address/model/Model.java[`Model.java`]

The `Model`,

* stores a `UserPref` object that represents the user's preferences.
* stores the Address Book data.
* stores the Hotel data.
* stores the BookKeeper data
* exposes an unmodifiable `ObservableList<Person>` ,  `ObservableList<Room>` , `ObservableList<Booking>` , `ObservableList<AvailableService>`, `ObservableList<Bill>` that can be 'observed' e.g. the UI can be bound to this list so that the UI automatically updates when the data in the list change.
* exposes Hotel's data.
* does not depend on any of the other three components.

[NOTE]
As a more OOP model, we can store a `Tag` list in `Address Book`, which `Person` can reference. This would allow `Address Book` to only require one `Tag` object per unique `Tag`, instead of each `Person` needing their own `Tag` object. An example of how such a model may look like is given below. +
 +
image:BetterModelClassDiagram.png[]

[[Design-Storage]]
=== Storage component (Sanchari)

.Structure of the Storage Component
image::StorageDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/address/storage/Storage.java[`Storage.java`]

The `Storage` component is responsible for serializing `Model` and deserializing Json data to facilitate reading and writing into the database. +
The `Storage` component can:

* can save `UserPref` objects in json format and read it back.
* can save the Address Book data in json format and read it back.
* can save Hotel data in json format and read it back.
* can save BookKeeper data in json format and read it back.

[[Design-Commons]]
=== Common classes

Classes used by multiple components are in the `seedu.addressbook.commons` package.

== Implementation

This section describes some noteworthy details on how certain features are implemented.

//tag::init[]
=== Hotel Initialization (Sanchari)
The following steps show how to set up a hotel by adding guests, rooms and services:

==== AddGuestCommand
===== Implementation
This command adds a guest into the hotel using their name, guest ID, phone and email.

The following steps show how the add guest feature works:

1. The `addguest` command entered by the user is parsed and the different fields are tokenized.
2. `AddGuestCommand#execute(Model model)` is invoked which checks for validity of the entered parameter values.
3. The command is then executed by creating a new Guest object using the parameter values entered and adding the Guest object into the Hotel.
4.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The diagram below shows the class diagram for AddGuestCommand.

.Class Diagram for AddGuestCommand
image::AddGuestClass.png[]

===== Design Considerations
* **Alternative 1 (current choice):** Creates a new Guest object in AddGuestCommandParser.
** Pros: Simpler to test and understand.
** Cons: Command object should not know details about model i.e. Person.
* **Alternative 2:** New Guest object is created and added to hotel in model.
** Pros: Command has no knowledge of Model and its attributes.
** Cons: More prone to error.

[[Initialization-AddService]]
==== AddService Command
===== Implementation
The following steps show how the AddService command is implemented:

1.  The command from user is parsed and undergoes checks for the validity of the `SERVICE_ID`, `COST` and `DESCRIPTION`.
2.  If the parameters are valid, `AddServiceCommand#execute(Model model)` is invoked, which checks if the service id exists.
3.  If the service id does not exist, a `AvailableService` object is created and `Model#add(AvailableService service)` is called to add an available service to hotel.
4.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The diagram below shows the class diagram for AddServiceCommand

.Class Diagram for AddServiceCommand
image::AddServiceClass.png[]

===== Design Considerations
* **Alternative 1 (current choice):** Creates a new Service object in AddServiceCommandParser.
** Pros: Simpler to test and understand.
** Cons: Command object should not know details about model i.e. Service.
* **Alternative 2:** New Service object is created and added to hotel in model.
** Pros: Command has no knowledge of Model and its attributes.
** Cons: More prone to error.


==== AddRoomCommand
===== Implementation
This command adds a room into the hotel using the room number, tier and the cost of the room.

The following steps show how the add room feature works:

1. The `addroom` command entered by the user is parsed and the different fields are tokenized.
2. `AddRoomCommand#execute(model)` is invoked which checks for validity of the arguments.
3. If all arguments are valid, a new Room object is created using the tokenized arguments and it is added into the hotel.
4.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The diagram below shows the class diagram for AddRoomCommand

.Class Diagram for AddRoomCommand
image::AddRoomClassDiagram.png[]

===== Design Considerations
* **Alternative 1 (current choice):** New Room object is created and added to hotel in Hotel.
** Pros: Command has no knowledge of Model and its attributes.
** Cons: More prone to error.
* **Alternative 2:** Creates a new Guest object in AddRoomCommandParser.
** Pros: Simpler to test and understand.
** Cons: Command object should not know details about model and its attributes i.e. Room.

The Diagram below shows the sequence diagram for AddRoomCommand. All Initialization commands above are similar in their interactions with the <<Design-Logic>> and <<Design-Model>>.

.Sequence Diagram for AddRoomCommand
image::AddRoomSequenceDiagram.png[]

The Diagram below shows the general activity sequence of the initialization feature.

.Activity Diagram of Hotel Initialization
image::AddCommandDiagram.png[]
//end:init[]

=== Hotel Services (Daniel)

==== Reserve Command
===== Implementation
This command makes a reservation under the specified guest's name for the specified duration.

The following steps show how the Reserve command is implemented.

1. The command from the user is tokenized and parsed.
2. `ReserveCommand#execute(Model model)` is invoked which checks if guest ID, room ID exists in the database and if there are any clashes with other bookings.
3. A new Booking object is created and added into the hotel database.

//tag::checkin[]
==== Checkin Command

This command checks in guest either with a room number, guest's name, and the end date of the stay.
Or by providing the booking ID.

===== Implementation

The following steps show how the CheckIn command is implemented.

1. The command is parsed by `CheckInCommandParser#parse(String args)` into list of pattern there (room number, guest id, end date of the stay or booking id).
2. If `BOOKING_ID` exists in the pattern, it will ignore the rest of the pattern and checkin using that booking id instead by creating `CheckInByIdCommand`
3. The `CheckInByIdCommand` will invoke `model#findBookingById(String BookigId)` which will create a normal `CheckInCommand`
4. `CheckInCommand` will call `model#checkIn` will be called.
5. The list in the UI will be updated by calling `model#updateFilteredRoomList(Predicate predicate)`
6. The room will be charged by calling `model#chargeRoomCost(RoomId roomId, RoomCost roomCost, Stay stay)`.
7. If all of the above is successfully executed, this will return a `CommandResult` object to show success message.

.Sequence Diagram for CheckInCommand
image::CheckInSequenceDiagram.png

===== Design Considerations

Below describes ideas that were considered when designing the command.

* **Alternative 1 (current choice):** Create a stay object which differentiate between the current stay and reservation.
** Pros: Could easily get the list of current stay.
** Cons: Requires more planning since we have to maintain 2 list now (stay and reservation).
* **Alternative 2:** Store all stay in a reservation object.
** Pros: Simple to implement.
** Cons: Could not differentiate between stay and reservation unless there is another instance in the reservation object.
//end::checkin[]

//tag::checkout[]
==== Checkout Command

This command checks out a guest from the hotel by providing a room number.

===== Implementation

The folowing steps show how the CheckOut command is implemented.

1. The command is parsed by `CheckOutCommandParser#parse(String args)` into list of pattern there (room number).
2. The `CheckOutCommandParser` will create `CheckOutCommand`
3. `CheckOutCommand` will call `model#checkOut` will be called.
4. The list in the UI will be updated by calling `model#updateFilteredRoomList(Predicate predicate)`
5. The room will clean up the previous bill by calling `model#deleteBill(RoomId roomId)`.
6. If all of the above is successfully executed, this will return a `CommandResult` object to show success message.
//end::checkout[]

//tag::extend[]

==== Extend Command

This command extend the booking of a guest by providing room number and end date of the stay.

==== Implementation

1. The command is parsed by `ExtendCommandParser#parse(String args)` into list of pattern there (room number and end date).
2. The `ExtendCommandParser` will create `ExtendCommand`
3. `ExtendCommand` will call `model#extendRoom` to extend the room in the hotel.
4. `ExtendCommand` will call `model#chargeExtendRoomCost` to charge the room according to the room cost and number of extra nights.
5. If this is successfully executer, this will return a `CommandResult` object to show success message.

//end::extend[]


=== Search feature

//tag::findguest[]
==== FindGuestCommand
===== Implementation
Currently this command only support searching for full name or/and id number.

The following steps show how the search guest feature works:

1.  The search command from the user is parsed into a list of pattern contained in the search command.

2.  The command then executes and filters the guest list based on the patterns.

The diagram below show how the search command store its pattern.

.Class diagram for FindGuestCommand
image::FindGuestCommand.png[]

The diagram below shows the execution of the command:

.Activity Diagram of Search Feature
image::SearchWorkflow.png[]

===== Design Considerations
* **Alternative 1 (current choice):** Store pattern as list of name and id.
** Pros: Simpler to test and understand.
** Cons: Difficult to extend the implementation.
* **Alternative 2:** Store pattern as a combination of Predicate.
** Pros: Easy to implement and add more complicated pattern.
** Cons: Harder to test, more prone to error.
//end::findguest[]

//tag::billingsystem[]
=== Billing System (Hui Ming)

The billing system is designed to aid hotel receptionists in their bookkeeping. It is oversen by the `BookKeeper` class, which keeps track of all bills in the hotel and facillitates in the manipulation of bills.
The bills are kept in a `UniqueBillList`, which ensures that there are no duplicate bills in the `BookKeeper` class.

The structure of the billing system is shown in the class diagram below:

.Class Diagram of Billing System
image::BillingClassDiagram.png[]

To utilize the billing system, users are provided with the following operations:

* `SetRoomCostCommand` -- Sets the cost of a room.
* `AddServiceCommand` -- Creates a chargeable service.
* `ChargeServiceCommand` -- Charges a guest for a requested service.
* `DeleteChargedServiceCommand` -- Removes a charged service from the bill of a guest.
* `FetchBillCommand` -- Fetches the bill of a guest, including the cost of the room.

The following activity diagram summarizes the typical procedure of billing a guest:

.Activity Diagram of Billing System
image::BillingActivityDiagram.png[]

==== SetRoomCost Command (Hui Ming)

This section goes through the implementation and design considerations of the `SetRoomCost` command.

===== Implementation

The following steps show how the command is implemented:

1.  The command from the user is parsed and undergoes checks for the validity of the given `ROOMNUMBER` and `COST`.
2.  If the parameters are valid, `SetRoomCostCommand#execute(Model model)` is invoked, which checks if the given room exists.
3.  If the room exists, a `RoomCost` object is created and `Model#setRoomCost(Room room, RoomCost roomCost)` is called.
4.  `Room##setCost(RoomCost roomcost)` is then invoked to set the cost of the room by setting the 'roomCost' attribute of the `Room` object.
5.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The sequence diagram below illustrates how the `SetRoomCost` command works with the input `setrcost rn/001 c/50`:

.Sequence Diagram of `SetRooomCost` Command
image::SetRoomCostSequenceDiagram.png[]

===== Design Considerations

Below describes ideas that were considered when designing the command.

* **Alternative 1 (current choice):** Store the cost of the room as an attribute in the `Room` object.
** Pros: Application of OOP concepts.
** Cons: Requires a deeper understanding of the Logic & Model components in order to implement.
* **Alternative 2:** Store the costs of rooms in a separate list (e.g. as a HashMap) in the Hotel component.
** Pros: Simple to implement.
** Cons: Might limit the relationship between the rooms and their costs.

==== AddService Command

The command is also a Hotel Initialization feature and is hence covered above in <<Initialization-AddService>>.

==== ChargeService Command (Hui Ming)

This section goes through the implementation and design considerations of the `ChargeService` command.

===== Implementation

The following steps show how the command is implemented:

1.  The command from the user is parsed and undergoes checks for the validity of the given `PERSONID`, `ROOMNUMBER` and `SERVICEID`.
2.  If the parameters are valid, `ChargeServiceCommand#execute(Model model)` is invoked, which checks if the given guest, room and service exist.
3.  If they exist, `Model#chargeService(RoomId roomId, AvailableService service)` is called which in following calls `BookKeeper#chargeServiceToBill(RoomId roomId, AvailableService service)`.
4.  The bill for the corresponding room is retrieved and `Bill#addService(AvailableService service)` is then invoked by `BookKeeper`.
5.  The service is added to stored list of chargeable objects in the bill and its cost is added to the stored total in the bill.
6.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The sequence diagram below illustrates how the `ChargeService` command works with the input `chargeservice i/A000000 rn/001 si/WC`:

.Sequence Diagram of `ChargeService` Command
image::ChargeServiceSequenceDiagram.png[]

===== Design Considerations

Below describes ideas that were considered when designing the command.

* **Alternative 1 (current choice):** Store the charged services in an ArrayList and the total cost as a double in the bill.
** Pros: Implementing the removal of charges services would be more direct and simple.
** Cons: Have to be careful with the calculation of the total cost.
* **Alternative 2:** Create another class to handle the list of charged services.
** Pros: Calculation of the total cost would be less prone to errors.
** Cons: Might cause the design of the application be unnecessarily complicated with many classes.
//end::billingsystem[]

==== DeleteChargedService Command (Hui Ming)

This section goes through the implementation and design considerations of the `DeleteChargedService` command.

===== Implementation

The following steps show how the command is implemented:

1.  The command from the user is parsed and undergoes checks for the validity of the given `PERSONID`, `ROOMNUMBER` and `SERVICEID`.
2.  If the parameters are valid, `DeleteChargedServiceCommand#execute(Model model)` is invoked, which checks if the given guest, room, service and bill exist.
3.  If they exist, `Model#deleteChargedService(RoomId roomId, AvailableService service)` is called which in following calls `BookKeeper#deleteChargedServiceFromBill(RoomId roomId, AvailableService service)`.
4.  The bill for the corresponding room is retrieved and `Bill#deleteService(AvailableService service)` is then invoked by `BookKeeper`.
5.  The service is removed from the stored list of chargeable objects in the bill and its cost is subtracted from the stored total in the bill.
6.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The sequence diagram below illustrates how the `DeleteChargedService` command works with the input `deletecservice i/A000000 rn/001 si/WC`:

.Sequence Diagram of `DeleteChargedService` Command
image::DeleteChargedServiceSequenceDiagram.png[]

===== Design Considerations

Below describes ideas that were considered when designing the command.

* **Alternative 1 (current choice):** Remove any one instance of the service in the list of charged services.
** Pros: Simple to implement.
** Cons: Does not make sense logically.
* **Alternative 2:** Remove the last instance of the service that was inserted.
** Pros: Makes sense logically.
** Cons: Need to keep track of the index, which unnecessarily complicates the program as the output would be the same.

==== FetchBill Command (Hui Ming)

This section goes through the implementation and design considerations of the `FetchBill` command.

===== Implementation

The following steps show how the command is implemented:

1.  The command from the user is parsed and undergoes checks for the validity of the given `PERSONID` and `ROOMNUMBER`, if provided.
2.  If the parameter/s are valid, `FetchBillCommand#execute(Model model)` is invoked, which checks if the given guest, room if `ROOMNUMBER` is provided, and bill/s exist.
3.  If they exist, different methods are called depending on whether `ROOMNUMBER` is provided:

* If `ROOMNUMBER` is provided:

a.  `Model#findBill(RoomId roomId)` is called to retrieve the bill for specified room.
b.  `Bill#getBillTotal()` is next called to get the total cost of expenses.
c.  `Model#updateFilteredBillList(Predicate predicate)` is then called to update the bill tab to show the bill details of the room.
d.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

* If `ROOMNUMBER` is not provided:

a.  `Model#getGuestBillsTotal(PersonId personId)` is called to get the total of all the bills of the guest.
b.  `Model#updateFilteredBillList(Predicate predicate)` is then called to update the bill tab to show all the bills belonging to the guest.
c.  If successful, a `CommandResult` object is created to show a success message in the feedback box of the ui.

The sequence diagram below illustrates how the `FetchBill` command works with the input `fetchbill i/A000000 rn/001`:

.Sequence Diagram of FetchBill Command
image::FetchBillSequenceDiagram.png[]

===== Design Considerations

Below describes ideas that were considered when designing the command.

* **Alternative 1 (current choice):** Allow the user to fetch the bill of a room of all bills of a person with a single command.
** Pros: Easier on user as they have lesser commands to remember.
** Cons: More considerations for different scenarios are needed, causing the implementation to be more complicated.
* **Alternative 2:** Have two separate commands to fetch the bill of a room and the bills of a person.
** Pros: Easier to parse the parameters for the command.
** Cons: User needs to remember more commands.

=== Logging

We are using `java.util.logging` package for logging. The `LogsCenter` class is used to manage the logging levels and logging destinations.

* The logging level can be controlled using the `logLevel` setting in the configuration file (See <<Implementation-Configuration>>)
* The `Logger` for a class can be obtained using `LogsCenter.getLogger(Class)` which will log messages according to the specified logging level
* Currently log messages are output through: `Console` and to a `.log` file.

*Logging Levels*

* `SEVERE` : Critical problem detected which may possibly cause the termination of the application
* `WARNING` : Can continue, but with caution
* `INFO` : Information showing the noteworthy actions by the App
* `FINE` : Details that is not usually noteworthy but may be useful in debugging e.g. print the actual list instead of just its size

[[Implementation-Configuration]]
=== Configuration

Certain properties of the application can be controlled (e.g user prefs file location, logging level) through the configuration file (default: `config.json`).

== Documentation

Refer to the guide <<Documentation#, here>>.

== Testing

Refer to the guide <<Testing#, here>>.

== Dev Ops

Refer to the guide <<DevOps#, here>>.

[appendix]
== Product Scope

*Target user profile*:

* has a need to manage a significant number of hotel guests
* needs to keep track of all guest information: checkins/services/bills
* prefers to view all guest information in one window
* prefers typing over mouse input
* prefer desktop apps over other types
* can type fast
* is reasonably comfortable using CLI apps


*Value proposition*: manage guests faster than a typical mouse/GUI driven app
//tag::userstories[]
[appendix]
== User Stories (Sanchari & Hui Ming)

Priorities: High (must have) - `* * \\*`, Medium (nice to have) - `* \\*`, Low (unlikely to have) - `*`

[width=""59%"",cols=""22%,<23%,<25%,<30%"",options=""header"",]
|=======================================================================
|Priority |As a ... |I want to ... |So that I can...

|`* * *` |receptionist|see which rooms are empty |check guests into them

|`* * *` |receptionist |get the bill details of guests |show the guests what they purchased

|`* * *` |busy receptionist |type as few things as possible |add in information fast

|`* * *` |receptionist |see which guests are VIPS |treat these guests with extra care

|`* * *` |receptionist |add people into the database |track hotel guests during their stay

|`* *` |receptionist |group people together |see which guests are in the same group/family

|`* *` |receptionist |change the tag of a room to served | know which rooms' requests have been fulfilled

|`* *` |receptionist |keep track of rooms that ordered room service |charge them accordingly

|`* *` |hotel staff |quickly see which rooms have been checked out |go clean the rooms

|`* * ` |cleaning staff |quickly see rooms with the ""clean my room tag"" |prioritize cleaning those rooms

|`* *` |receptionist |sort rooms into different categories |search for rooms more easily

|`* *` |receptionist |apply discounts to customers' bills |charge customers according to the hotel's ongoing promotions

|`* *` |receptionist |keep track of the guests staying in each room |address them by name

|`* *` |receptionist |compare two different rooms |see which room is more suitable for the guest

|`* *` |receptionist |create shortcuts/presets |conveniently carry out routine tasks

|`* *` |receptionist |see basic statistics |show my boss when they request for them

|`* *` |receptionist |see as many information as possible |find out certain details quickly

|`* *` |receptionist |be shown suggested keywords as I type |enter information quickly

|`* *` |receptionist |execute the same command on different rooms |efficiently carry out my job

|`*` |receptionist |see the online bookings that guests have made |efficiently check guests in

|=======================================================================
//end::userstories[]

//tag::usecases[]
[appendix]
== Use Cases (Hui Ming)

(For all use cases below, the *System* is the `Morpheus` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== Use cases example:
=== Use Case: UC01 - Add a guest

*MSS*

1.  User requests to add a guest
2.  User supplies guest name, id, phone number, email & tags
3.  Morpheus adds the guest to the application
+
Use case ends.

*Extensions*

[none]
* 2a. The guest already exists in the application.
+
[none]
** 2a1. Morpheus shows an error message.
+
Use case ends.

=== Use Case: UC02 - Add a room

*MSS*

1.  User requests to add a room
2.  User supplies room number, tier and cost
3.  Morpheus adds the room to the application
+
Use case ends.

*Extensions*

* 2a. The room already exists in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC03 - Add a tier

*MSS*

1.  User requests to add a tier to a room
2.  User supplies tier and room number
3.  Morpheus adds a tier to the application
+
Use case ends.

*Extensions*

* 2a. The room already exists in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room already has a tier
+
** 2b1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC04 - Add a service

*MSS*

1.  User requests to add a service
2.  User supplies service id, description and cost
3.  Morpheus adds the service to the application
+
Use case ends.

*Extensions*

* 2a. The service already exists in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC05 - Reserve a room

*MSS*

1.  User requests to reserve a room
2.  User supplies guest id, room number, start and end dates of reservation
3.  Morpheus reserves the room
+
Use case ends.

*Extensions*

* 2a. The guest does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room does not exist in the application
+
** 2b1. Morpheus shows an error message
+
Use case ends.
* 2c. The room is already reserved/occupied
+
** 2c1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC06 - Check in a guest

*MSS*

1.  User requests to check in a guest
2.  User supplies guest id, room number end date of check out
3.  Morpheus marks the room as occupied
+
Use case ends.

*Extensions*

* 2a. The guest does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room does not exist in the application
+
** 2b1. Morpheus shows an error message
+
Use case ends.
* 2c. The room is already reserved/occupied
+
** 2c1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC07 - Check out a guest

*MSS*

1.  User requests to check out a guest
2.  User supplies room number
3.  Morpheus marks the room as unoccupied
+
Use case ends.

*Extensions*

* 2a. The room does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room is not occupied
+
** 2b1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC08 - Extend the stay of a guest

*MSS*

1.  User requests to extend the stay of a guest
2.  User supplies room number and new date to check out
3.  Morpheus updates the period of time where the room is occupied
+
Use case ends.

*Extensions*

* 2a. The room does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room is not occupied
+
** 2b1. Morpheus shows an error message
+
Use case ends.
* 2c. The room is reserved by another guest
+
** 2c1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC09 - Charging a guest for a service

*MSS*

1.  User requests to charge a guest for a service
2.  User supplies guest id, room number and service id
3.  Morpheus charges the service to the bill of the guest
+
Use case ends.

*Extensions*

* 2a. The guest does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room does not exist in the application
+
** 2b1. Morpheus shows an error message
+
Use case ends.
* 2c. The service does not exist in the application
+
** 2c1. Morpheus shows an error message
+
Use case ends.
* 2d. The guest is not checked into the specified room
+
** 2d1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC10 - Fetch the bills of a guest

*MSS*

1.  User requests to fetch the bill of a guest
2.  User supplies guest id
3.  Morpheus shows the total outstanding payment of the guest and the bill details
+
Use case ends.

*Extensions*

* 2a. The guest does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The guest does not have outstanding bills
+
** 2b1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC11 - Remove a charged service from a bill

*MSS*

1.  User requests to remove a charged service from a bill
2.  User supplies guest id, room number and service id
3.  Morpheus removed charged service from the bill of the guest
+
Use case ends.

*Extensions*

* 2a. The guest does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
* 2b. The room does not exist in the application
+
** 2b1. Morpheus shows an error message
+
Use case ends.
* 2c. The service does not exist in the application
+
** 2c1. Morpheus shows an error message
+
Use case ends.
* 2d. The guest does not have outstanding bills
+
** 2d1. Morpheus shows an error message
+
Use case ends.
* 2e. The bill does not have the charged service
+
** 2e1. Morpheus shows an error message
+
Use case ends.

=== Use Case: UC12 - Search for a guest

*MSS*

1.  User requests to search for a guest
2.  User supplies guest id and/or name
3.  Morpheus shows a list of guests with matching id/names
+
Use case ends.

=== Use Case: UC13 - Search for a room

*MSS*

1.  User requests to search for a room
2.  User supplies guest id and/or name and/or room number
3.  Morpheus shows a list of rooms with matching id/names/room bumbers
+
Use case ends.

=== Use Case: UC14 - Search for a booking

*MSS*

1.  User requests to search for a guest
2.  User supplies guest id and/or name and/or room number
3.  Morpheus shows a list of bookings with matching id/names/room numbers
+
Use case ends.

=== Use Case: UC15 - Delete a guest

*MSS*

1.  User requests to delete a guest
2.  User supplies index of guest or guest id
3.  Morpheus deletes the guest from the application
+
Use case ends.

*Extensions*

* 2a. The guest does not exist in the application
+
** 2a1. Morpheus shows an error message
+
Use case ends.
//end::usecases[]

[appendix]
== Non Functional Requirements

.  Should work on any <<mainstream-os,mainstream OS>> as long as it has Java `11` or above installed.
.  Should be able to hold up to 1000 persons without a noticeable sluggishness in performance for typical usage.
.  Should be able to hold up to 1000 rooms without a noticeable sluggishness in performance for typical usage.
.  Should be able to handle up to 10000 requests per day.
.  A user with above average typing speed for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks faster using commands than using the mouse.
.  Should not consume more than 200 megabytes of storage (should optimize encoded data).
.  Should be able to restart without loss of data.
.  Should be able to store back-ups data in case of breaking down.

[appendix]
== Glossary
[[mainstream-os]] Mainstream OS::
Windows, Linux, Unix, OS-X
[[private-contact-detail]] Private contact detail::
A contact detail that is not meant to be shared with others


[appendix]
//tag::Testing[]
== Instructions for Manual Testing (Sanchari)

Given below are instructions to test the app manually.

[NOTE]
These instructions only provide a starting point for testers to work on; testers are expected to do more _exploratory_ testing.

=== Launch and Shutdown

. Initial launch

.. Download the jar file and copy into an empty folder
.. Double-click the jar file +
   Expected: Shows the GUI with a set of sample data. The window size may not be optimum.

. Saving window preferences

.. Resize the window to an optimum size. Move the window to a different location. Close the window.
.. Re-launch the app by double-clicking the jar file. +
   Expected: The most recent window size and location is retained.

=== Adding a guest

. Adding a guest when all guests are listed.

.. Prerequisites: List all persons using the `switch guest` command. Multiple guests in the list.
.. Test case: `addguest n/Joey i/J000000 p/12345679 e/joey@email.com t/VIP` +
   Expected: Guest Joey is added to the list. Details of the added Guest shown in the status message.
.. Test case: `addguest n/Jolene i/J000000 p/12345679 e/jolene@email.com t/VIP` +
   Expected: Guest Id clashes with an existing guest. No Guest is added. Error details shown in the status message.
.. Other incorrect addguest commands to try: `addguest`, `addguest i/P000000 p/12345679 e/joey@email.com` +
   Expected: Similar to previous.

=== Adding a room

. Adding a room when all rooms are listed.

.. Prerequisites: List all rooms using the `switch room` command. Multiple rooms in the list.
.. Test case: `addroom rn/300 ti/GOLD c/300.00` +
   Expected: Room 300 is added to the list. Details of the added Room shown in the status message.
.. Test case: `addroom rn/300 ti/GOLD c/300.00` +
   Expected: Room Id clashes with an existing room. No Room is added. Error details shown in the status message.
.. Test case: `addroom rn/400 ti/Gold c/300.00` +
   Expected: Invalid Tier value. No Room is added. Error details shown in the status message.
.. Other incorrect addroom commands to try: `addroom`, `addroom rn/500 ti/BRONZE` +
   Expected: Similar to previous.

=== Adding a tier

. Adding a tier and setting it to rooms

.. Prerequisites: List all rooms using the `switch room` command. Multiple rooms in the list.
.. Test case: `addtier ti/GOLD rn/001 002 003`
    Expected: Sets the tier for rooms `001`, `002`, and `003` to `GOLD`
.. Test case: `addtier ti/Gold rn/001 002 003`
    Expected: Invalid tier value. No tier added. Error message shown.
.. Other invalid addtier commands to try: `addtier` , `addtier ti/BRONZE rn/000`

=== Adding a service

. Adding a service when all services are listed.

.. Prerequisites: List all service using the `switch service` command. Multiple services in the list.
.. Test case: `addservice si/WC d/Wash clothes c/100.00` +
   Expected: Service WC is added to the list. Details of the added Service shown in the status message.
.. Test case: `addservice si/WC d/Other service c/100.00` +
   Expected: Service Id clashes with an existing service. No service is added. Error details shown in the status message.
.. Test case: `addservice si/WC c/100.00` +
   Expected: Invalid description value. No service is added. Error details shown in the status message.
.. Other incorrect addservice commands to try: `addservice`, `addservice c/190.00` +
   Expected: Similar to previous.

=== Reserving a room

. Adding a booking when all bookings are listed

.. Prerequisites: List all the bookings by using the `switch booking` command. Multiple bookings shown.
.. Test case: `reserve i/i000000 rn/001 fd/2020-12-12 td/2020-12-24` +
    Expected: Room number `001` is reserved by person `I000000` from `2020-12-12` to `2020-12-24`
.. Test case: `reserve i/B000000 rn/001 fd/2020-12-13 td/2020-12-23` +
    Expected: There is a clash in booking dates for the same room. Error details shown in the result display box.
.. Test case: `reserve i/Bzagda rn/001 fd/2020-12-13 td/2020-12-23`
    Expected: No such person found. No booking made. Error details shown in the status message.
.. Other incorrect reserve commands to try: `reserve`, `reserve i/A000000` , `reserve i/i000000 rn/004 fd/2012-12-12 td/2012-12-24`

=== Checking in and out guests

. Dealing with check-ins and check-outs

.. Prerequisites: List all bookings by using the command `switch booking`
.. Test case: `checkin i/i000000 rn/001 td/2020-12-24` +
    Expected: Guest `i000000` is checked into room `001`
.. Test case: `checkin i/B000000 rn/5602 td/2020-12-23` +
    Expected: There is no such room. Error message shown in result display box.
.. Test case: `checkout rn/001` +
    Expected: Guest is checked out of room `001`
.. Test case: `checkout rn/009` +
    Expected: Room `009` has no guests. Error message is shown in the result display box.
.. Other incorrect checkin/checkout commands to try: `checkin`, `checkin i/A000000` , `checkin i/i000000 rn/004 fd/2012-12-12 td/2012-12-24`, `checkout` , `checkout rn/000`


=== Extending the stay of a guest

. Dealing with extension of a stay.

.. Prerequisites: List all the stays by using the `switch room` command. Stays are shown in the rooms.
.. Test case: `extend rn/101 td/2020-04-20` +
    Expected: Room number `101` 's stay is extended until `2020-04-20`
.. Test case: `extend rn/006 td/2020-04-20` +
    Expected: There is no guest checked into room `006`. Stay cannot be extended. Error details shown in the result display box.
.. Test case: `extend rn/001 fd/2012-12-12` +
    Expected: Invalid date. Date has passed. Stay cannot be extended. Error details shown in the result display box.
.. Other incorrect extend commands to try: `extend`, `reserve rn/000` , `extend td/2012-12-12`

=== Charging a service

.Charging a service to the guest's tab.

.. Prerequisites: List all the stays by using the `switch room` command. Stays are shown in the rooms.
.. Test case: `chargeservice i/A000000 rn/004 si/WC` +
    Expected: Charges service with the ID `WC` for room `100` to the guest with ID `A000000` 's bill.
.. Test case: `chargeservice i/R000000 rn/004 si/WC` +
    Expected: Guest `R000000` is not checked in. No service can be added to his bill. Error details shown in the result display box.
.. Other incorrect chargeservice commands to try: `chargeservice`, `chargeservice i/R000000 rn/000 si/WC` , `chargeservice i/R000000 rn/100 si/DD

=== Fetching the bill of a guest

.Retrieving the bill of a guest

.. Prerequisites: List all the stays by using the `switch room` command. Stays are shown in the rooms.
.. Test case: `fetchbill i/A000000` +
    Expected: Shows the entire bill, consisting of all costs incurred, for guest with ID `G1231231X` 's stay up till present moment.
.. Test case: `fetchbill i/R000000` +
    Expected: Guest `R000000` is not checked in. His bill cannot be shown. Error details shown in the result display box.
.. Other incorrect fetchbill commands to try: `fetchbill`

=== Deleting service from a bill

.Deleting a service from a bill

.. Prerequisites: List all bills by using the `switch bill` command
.. Test case: `deletecservice i/G1231231X rn/100 si/WC`
    Expected: Removes service with ID `WC` from guest with ID `G1231231X` 's bill for room `100`
.. Test case: `deletecservice i/B000000 rn/100 si/WC`
    Expected: Guest `B000000` does not have the service `WC` in their bill. Error message shown in the result display box.
.. Other incorrect deletecservice commands to try: `deletecservice` , `deletecservice i/A000000 rn/000`

=== Finding a guest

.Finding a guest from the list

.. Prerequisites: List all guests by using the `switch guest` command. Guests are listed.
.. Test case: `findguest i/A0000000 n/Alice`
    Expected: Shows persons with name: `Alice` or ID: `A1000000`
.. Test case: `findguest`
    Expected: Invalid command format. Error message is shown in the result display box.
.. Other incorrect findguest commands to try: `findguest i/` , `findguest n/`

=== Finding a room

.Finding a room related to a guest's reservation/stay

.. Prerequisites: List all rooms by using the `switch room` command. Rooms are listed.
.. Test case: `findroom i/A000000 rn/001 n/Tuan Le`
    Expected: Shows rooms booked by Guest with name: `Tuan Le` and/or ID: `A000000`
.. Test case: `findroom`
    Expected: Invalid command format. Error message is shown in the result display box.
.. Other incorrect findroom commands to try: `findroom i/` , `findroom n/`

=== Finding a booking

.Finding a booking made by a guest

.. Prerequisites: List all bookings by using the `switch room` command. Rooms are listed.
.. Test case: `findbooking n/Alice rn/001`
    Expected: Shows booking of `Alice` or of room `001`.
.. Test case: `findbooking`
    Expected: Invalid command format. Error message is shown in the result display box.
.. Other incorrect findbooking commands to try: `findbooking rn/` , `findbooking n/`

=== Deleting a person

. Deleting a Guest while all Guests are listed

.. Prerequisites: List all guests using the `switch guest` command. Multiple guests in the list.
.. Test case: `delete 1` +
   Expected: First Guest is deleted from the list. Details of the deleted Guest shown in the status message.
.. Test case: `delete 0` +
   Expected: Index is out of bounds. No Guest is deleted. Error details shown in the status message. Status bar remains the same.
.. Other incorrect delete commands to try: `delete`, `delete x` (where x is larger than the list size)
   Expected: Similar to previous.

=== Saving data

. Dealing with missing/corrupted data files

.. Prerequisites: Get access to the data files.
.. Test case: Delete hotel.json +
   Expected: Morpheus will load addressbook and hotel with sample data.
.. Other tests to try: Delete some '{}' in hotel.json +
    Expected: Morpheus will restart with an empty addressbook and hotel.

//end::Testing[]

[appendix]
//tag::effort[]
== Effort +
(Sanchari)
=== Overview
Morpheus is an extension from AB3 and is considerably more complex than AB3. We have incorporated several new features which required extending the
UI, Storage and Model components of Morpheus. We extended current AB3 features (which only had 1 entity type: AddressBook) to include more entity types such as Hotel and BookKeeper which in turn
contained more entities such as Rooms and Bills. We did this so as to be able to create an application that allows seamless management of a hotel's daily
activities. As there were many new things to add on to AB3, the entire team put in their collaborative effort to create the end product.

=== Challenges

* Planning out the structure and architecture of the application

** A hotel is a complex system of activities, thus we had to hold several meetings to discuss what would be the structure of our application so as to allow
management of all the activities in one app.

* New storage components for the `Hotel` and `BookKeeper`

** As the AddressBook only stored persons, we has to extend the storage system to keep track of the hotel's data and the finance data in the `Hotel` and `BookKeeper`
classes respectively. This required thorough understanding of AB3's storage system.

* New Commands to aid the job of a hotel receptionist.

** We had to extend AB3's current implementation of `Logic` as a hotel receptionist has to manage many more things than a person list. Hence, through
thorough understanding of the `Model` and `Logic` component, we implemented a variety of new commands that works with the model to digitize the management of a hotel.

* User Interface

** We wanted to show all of the hotel's activity and data in 1 window. As such, it was necessary to upgrade AB3's UI to incorporate the hotel's data.
The Ui was improved and edited using JavaFx and CSS. All bugs and errors that were reflected in the Ui were tested and fixed by the team.

=== Conclusion
We believe that this was a difficult project to execute as a hotel has many interlinked components working together. However, through the combined effort
of the entire team, we believe that we have created an end-product that is able to manage the hotel's important activities altogether in one application.
//end:effort[]
",12478,False,2046.8086359024442,median
"//===--- SILGenBridging.cpp - SILGen for bridging to Clang ASTs -----------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

#include ""ArgumentScope.h""
#include ""Callee.h""
#include ""RValue.h""
#include ""ResultPlan.h""
#include ""SILGenFunction.h""
#include ""Scope.h""
#include ""swift/AST/DiagnosticsSIL.h""
#include ""swift/AST/ExistentialLayout.h""
#include ""swift/AST/ForeignErrorConvention.h""
#include ""swift/AST/GenericEnvironment.h""
#include ""swift/AST/ParameterList.h""
#include ""swift/AST/ProtocolConformance.h""
#include ""swift/SIL/SILArgument.h""
#include ""swift/SIL/SILUndef.h""
#include ""swift/SIL/TypeLowering.h""

using namespace swift;
using namespace Lowering;

/// Convert to the given formal type, assuming that the lowered type of
/// the source type is the same as its formal type.  This is a reasonable
/// assumption for a wide variety of types.
static ManagedValue emitUnabstractedCast(SILGenFunction &SGF, SILLocation loc,
                                         ManagedValue value,
                                         CanType sourceFormalType,
                                         CanType targetFormalType) {
  if (value.getType() == SGF.getLoweredType(targetFormalType))
    return value;

  return SGF.emitTransformedValue(loc, value,
                                  AbstractionPattern(sourceFormalType),
                                  sourceFormalType,
                                  AbstractionPattern(targetFormalType),
                                  targetFormalType);
}

static bool shouldBridgeThroughError(SILGenModule &SGM, CanType type,
                                     CanType targetType) {
  // Never use this logic if the target type is AnyObject.
  if (targetType->isEqual(SGM.getASTContext().getAnyObjectType()))
    return false;

  auto errorProtocol = SGM.getASTContext().getErrorDecl();
  if (!errorProtocol) return false;

  // Existential types are convertible to Error if they are, or imply, Error.
  if (type.isExistentialType()) {
    auto layout = type->getExistentialLayout();
    for (auto proto : layout.getProtocols()) {
      if (proto->getDecl() == errorProtocol ||
          proto->getDecl()->inheritsFrom(errorProtocol)) {
        return true;
      }
    }

    // They're also convertible to Error if they have a class bound that
    // conforms to Error.
    if (auto cls = layout.superclass) {
      type = cls->getCanonicalType();

    // Otherwise, they are not convertible to Error.
    } else {
      return false;
    }
  }

  auto optConf = SGM.SwiftModule->lookupConformance(type, errorProtocol);
  return optConf.hasValue();
}

/// Bridge the given Swift value to its corresponding Objective-C
/// object, using the appropriate witness for the
/// _ObjectiveCBridgeable._bridgeToObjectiveC requirement.
static Optional<ManagedValue>
emitBridgeNativeToObjectiveC(SILGenFunction &SGF,
                             SILLocation loc,
                             ManagedValue swiftValue,
                             CanType swiftValueType,
                             CanType bridgedType,
                             ProtocolConformance *conformance) {
  // Find the _bridgeToObjectiveC requirement.
  auto requirement = SGF.SGM.getBridgeToObjectiveCRequirement(loc);
  if (!requirement) return None;

  // Retrieve the _bridgeToObjectiveC witness.
  auto witness = conformance->getWitnessDecl(requirement, nullptr);
  assert(witness);

  // Determine the type we're bridging to.
  auto objcTypeReq = SGF.SGM.getBridgedObjectiveCTypeRequirement(loc);
  if (!objcTypeReq) return None;

  Type objcType = conformance->getTypeWitness(objcTypeReq, nullptr);
  assert(objcType);

  // Create a reference to the witness.
  SILDeclRef witnessConstant(witness);
  auto witnessRef = SGF.emitGlobalFunctionRef(loc, witnessConstant);

  // Determine the substitutions.
  auto witnessFnTy = witnessRef->getType();

  // Compute the substitutions.

  // FIXME: Figure out the right SubstitutionMap stuff if the witness
  // has generic parameters of its own.
  assert(!cast<FuncDecl>(witness)->isGeneric() &&
         ""Generic witnesses not supported"");

  auto *dc = cast<FuncDecl>(witness)->getDeclContext();
  auto *genericSig = dc->getGenericSignatureOfContext();
  auto typeSubMap = swiftValueType->getContextSubstitutionMap(
      SGF.SGM.SwiftModule, dc);

  // Substitute into the witness function type.
  witnessFnTy = witnessFnTy.substGenericArgs(SGF.SGM.M, typeSubMap);

  // We might have to re-abstract the 'self' value if it is an
  // Optional.
  AbstractionPattern origSelfType(witness->getInterfaceType());
  origSelfType = origSelfType.getFunctionInputType();

  swiftValue = SGF.emitSubstToOrigValue(loc, swiftValue,
                                        origSelfType,
                                        swiftValueType,
                                        SGFContext());

  // The witness may be more abstract than the concrete value we're bridging,
  // for instance, if the value is a concrete instantiation of a generic type.
  //
  // Note that we assume that we don't ever have to reabstract the parameter.
  // This is safe for now, since only nominal types currently can conform to
  // protocols.
  SILFunctionConventions witnessConv(witnessFnTy.castTo<SILFunctionType>(),
                                     SGF.SGM.M);
  if (witnessConv.isSILIndirect(witnessConv.getParameters()[0])
      && !swiftValue.getType().isAddress()) {
    auto tmp = SGF.emitTemporaryAllocation(loc, swiftValue.getType());
    SGF.B.createStoreBorrowOrTrivial(loc, swiftValue.borrow(SGF, loc), tmp);
    swiftValue = ManagedValue::forUnmanaged(tmp);
  }

  SmallVector<Substitution, 4> subs;
  if (genericSig)
    genericSig->getSubstitutions(typeSubMap, subs);

  // Call the witness.
  SILType resultTy = SGF.getLoweredType(objcType);
  SILValue bridgedValue =
      SGF.B.createApply(loc, witnessRef, witnessFnTy, resultTy, subs,
                        swiftValue.borrow(SGF, loc).getValue());

  auto bridgedMV = SGF.emitManagedRValueWithCleanup(bridgedValue);

  // The Objective-C value doesn't necessarily match the desired type.
  bridgedMV = emitUnabstractedCast(SGF, loc, bridgedMV,
                                   objcType->getCanonicalType(), bridgedType);

  return bridgedMV;
}

/// Bridge the given Objective-C object to its corresponding Swift
/// value, using the appropriate witness for the
/// _ObjectiveCBridgeable._unconditionallyBridgeFromObjectiveC requirement.
static Optional<ManagedValue>
emitBridgeObjectiveCToNative(SILGenFunction &SGF,
                             SILLocation loc,
                             ManagedValue objcValue,
                             CanType bridgedType,
                             ProtocolConformance *conformance) {
  // Find the _unconditionallyBridgeFromObjectiveC requirement.
  auto requirement =
    SGF.SGM.getUnconditionallyBridgeFromObjectiveCRequirement(loc);
  if (!requirement) return None;

  // Find the _ObjectiveCType requirement.
  auto objcTypeRequirement = SGF.SGM.getBridgedObjectiveCTypeRequirement(loc);
  if (!objcTypeRequirement) return None;

  // Retrieve the _unconditionallyBridgeFromObjectiveC witness.
  auto witness = conformance->getWitnessDeclRef(requirement, nullptr);
  assert(witness);

  // Retrieve the _ObjectiveCType witness.
  auto objcType = conformance->getTypeWitness(objcTypeRequirement, nullptr);
  assert(objcType);

  // Create a reference to the witness.
  SILDeclRef witnessConstant(witness.getDecl());
  auto witnessRef = SGF.emitGlobalFunctionRef(loc, witnessConstant);

  // Determine the substitutions.
  auto witnessFnTy = witnessRef->getType().castTo<SILFunctionType>();

  CanType swiftValueType = conformance->getType()->getCanonicalType();
  auto genericSig = witnessFnTy->getGenericSignature();
  SubstitutionMap typeSubMap;
  if (genericSig)
    typeSubMap = genericSig->getSubstitutionMap(witness.getSubstitutions());

  // Substitute into the witness function type.
  witnessFnTy = witnessFnTy->substGenericArgs(SGF.SGM.M, typeSubMap);

  // The witness takes an _ObjectiveCType?, so convert to that type.
  CanType desiredValueType = OptionalType::get(objcType)->getCanonicalType();
  objcValue = emitUnabstractedCast(SGF, loc, objcValue, bridgedType,
                                   desiredValueType);

  // Call the witness.
  auto metatypeParam = witnessFnTy->getParameters()[1];
  assert(isa<MetatypeType>(metatypeParam.getType()) &&
         cast<MetatypeType>(metatypeParam.getType()).getInstanceType()
           == swiftValueType);
  SILValue metatypeValue =
    SGF.B.createMetatype(loc, metatypeParam.getSILStorageType());

  auto witnessCI = SGF.getConstantInfo(witnessConstant);
  CanType formalResultTy = witnessCI.LoweredType.getResult();

  auto subs = witness.getSubstitutions();

  // Set up the generic signature, since formalResultTy is an interface type.
  GenericContextScope genericContextScope(SGF.SGM.Types, genericSig);
  CalleeTypeInfo calleeTypeInfo(
      witnessFnTy,
      AbstractionPattern(genericSig, formalResultTy),
      swiftValueType);
  SGFContext context;
  ResultPlanPtr resultPlan =
      ResultPlanBuilder::computeResultPlan(SGF, calleeTypeInfo, loc, context);
  ArgumentScope argScope(SGF, loc);
  RValue result =
      SGF.emitApply(std::move(resultPlan), std::move(argScope), loc,
                    ManagedValue::forUnmanaged(witnessRef), subs,
                    {objcValue, ManagedValue::forUnmanaged(metatypeValue)},
                    calleeTypeInfo, ApplyOptions::None, context);
  return std::move(result).getAsSingleValue(SGF, loc);
}

static ManagedValue emitBridgeBoolToObjCBool(SILGenFunction &SGF,
                                             SILLocation loc,
                                             ManagedValue swiftBool) {
  // func _convertBoolToObjCBool(Bool) -> ObjCBool
  SILValue boolToObjCBoolFn
    = SGF.emitGlobalFunctionRef(loc, SGF.SGM.getBoolToObjCBoolFn());

  SILType resultTy =SGF.getLoweredLoadableType(SGF.SGM.Types.getObjCBoolType());

  SILValue result = SGF.B.createApply(loc, boolToObjCBoolFn,
                                      boolToObjCBoolFn->getType(),
                                      resultTy, {}, swiftBool.forward(SGF));
  return SGF.emitManagedRValueWithCleanup(result);
}

static ManagedValue emitBridgeBoolToDarwinBoolean(SILGenFunction &SGF,
                                                  SILLocation loc,
                                                  ManagedValue swiftBool) {
  // func _convertBoolToDarwinBoolean(Bool) -> DarwinBoolean
  SILValue boolToDarwinBooleanFn
    = SGF.emitGlobalFunctionRef(loc, SGF.SGM.getBoolToDarwinBooleanFn());

  SILType resultTy =
      SGF.getLoweredLoadableType(SGF.SGM.Types.getDarwinBooleanType());

  SILValue result = SGF.B.createApply(loc, boolToDarwinBooleanFn,
                                      boolToDarwinBooleanFn->getType(),
                                      resultTy, {}, swiftBool.forward(SGF));
  return SGF.emitManagedRValueWithCleanup(result);
}

static ManagedValue emitBridgeForeignBoolToBool(SILGenFunction &SGF,
                                                SILLocation loc,
                                                ManagedValue foreignBool,
                                                SILDeclRef bridgingFnRef) {
  // func _convertObjCBoolToBool(ObjCBool) -> Bool
  SILValue bridgingFn = SGF.emitGlobalFunctionRef(loc, bridgingFnRef);

  SILType resultTy = SGF.getLoweredLoadableType(SGF.SGM.Types.getBoolType());

  SILValue result = SGF.B.createApply(loc, bridgingFn, bridgingFn->getType(),
                                      resultTy, {}, foreignBool.forward(SGF));
  return SGF.emitManagedRValueWithCleanup(result);
}

static ManagedValue emitManagedParameter(SILGenFunction &SGF, SILLocation loc,
                                         SILParameterInfo param,
                                         SILValue value) {
  const TypeLowering &valueTL = SGF.getTypeLowering(value->getType());

  switch (param.getConvention()) {
  case ParameterConvention::Direct_Owned:
    // Consume owned parameters at +1.
    return SGF.emitManagedRValueWithCleanup(value, valueTL);

  case ParameterConvention::Direct_Guaranteed:
    // If we have a guaranteed parameter, the object should not need to be
    // retained or have a cleanup.
    return ManagedValue::forUnmanaged(value);

  case ParameterConvention::Direct_Unowned:
    // We need to independently retain the value.
    return SGF.emitManagedRetain(loc, value, valueTL);

  case ParameterConvention::Indirect_Inout:
    return ManagedValue::forLValue(value);

  case ParameterConvention::Indirect_In_Guaranteed:
    if (valueTL.isLoadable()) {
      return SGF.B.createLoadBorrow(loc, ManagedValue::forUnmanaged(value));
    } else {
      return ManagedValue::forUnmanaged(value);
    }

  case ParameterConvention::Indirect_In:
    if (valueTL.isLoadable()) {
      return SGF.emitLoad(loc, value, valueTL, SGFContext(), IsTake);
    } else {
      return SGF.emitManagedRValueWithCleanup(value, valueTL);
    }

  case ParameterConvention::Indirect_In_Constant:
  case ParameterConvention::Indirect_InoutAliasable:
    llvm_unreachable(""unexpected convention"");
  }
  llvm_unreachable(""bad convention"");
}

static void expandTupleTypes(CanType type, SmallVectorImpl<CanType> &results) {
  if (auto tuple = dyn_cast<TupleType>(type)) {
    for (auto eltType : tuple.getElementTypes())
      expandTupleTypes(eltType, results);
  } else {
    results.push_back(type);
  }
}

/// Recursively expand all the tuples in the given parameter list.
/// Callers assume that the resulting array will line up with the
/// SILFunctionType's parameter list, which is true as along as there
/// aren't any indirectly-passed tuples; we should be safe from that
/// here in the bridging code.
static SmallVector<CanType, 8>
expandTupleTypes(AnyFunctionType::CanParamArrayRef params) {
  SmallVector<CanType, 8> results;
  for (auto param : params)
    expandTupleTypes(param.getType(), results);
  return results;
}

static CanAnyFunctionType getBridgedBlockType(SILGenModule &SGM,
                                              CanAnyFunctionType blockType) {
  return SGM.Types.getBridgedFunctionType(AbstractionPattern(blockType),
                                         blockType, blockType->getExtInfo());
}

static void buildFuncToBlockInvokeBody(SILGenFunction &SGF,
                                       SILLocation loc,
                                       CanAnyFunctionType formalFuncType,
                                       CanAnyFunctionType formalBlockType,
                                       CanSILFunctionType funcTy,
                                       CanSILFunctionType blockTy,
                                       CanSILBlockStorageType blockStorageTy) {
  Scope scope(SGF.Cleanups, CleanupLocation::get(loc));
  SILBasicBlock *entry = &*SGF.F.begin();
  SILFunctionConventions blockConv(blockTy, SGF.SGM.M);
  SILFunctionConventions funcConv(funcTy, SGF.SGM.M);

  // Make sure we lower the component types of the formal block type.
  formalBlockType = getBridgedBlockType(SGF.SGM, formalBlockType);

  // Set up the indirect result.
  SILType blockResultTy = blockTy->getAllResultsType();
  SILValue indirectResult;
  if (blockTy->getNumResults() != 0) {
    auto result = blockTy->getSingleResult();
    if (result.getConvention() == ResultConvention::Indirect) {
      indirectResult = entry->createFunctionArgument(blockResultTy);
    }
  }

  // Get the captured native function value out of the block.
  auto storageAddrTy = SILType::getPrimitiveAddressType(blockStorageTy);
  auto storage = entry->createFunctionArgument(storageAddrTy);
  auto capture = SGF.B.createProjectBlockStorage(loc, storage);
  auto &funcTL = SGF.getTypeLowering(funcTy);
  auto fn = SGF.emitLoad(loc, capture, funcTL, SGFContext(), IsNotTake);

  // Collect the block arguments, which may have nonstandard conventions.
  assert(blockTy->getParameters().size() == funcTy->getParameters().size()
         && ""block and function types don't match"");

  auto nativeParamTypes = expandTupleTypes(formalFuncType.getParams());
  auto bridgedParamTypes = expandTupleTypes(formalBlockType.getParams());

  SmallVector<ManagedValue, 4> args;
  for (unsigned i : indices(funcTy->getParameters())) {
    auto &param = blockTy->getParameters()[i];
    SILType paramTy = blockConv.getSILType(param);
    SILValue v = entry->createFunctionArgument(paramTy);
    ManagedValue mv;
    
    // If the parameter is a block, we need to copy it to ensure it lives on
    // the heap. The adapted closure value might outlive the block's original
    // scope.
    if (SGF.getSILType(param).isBlockPointerCompatible()) {
      // We still need to consume the original block if it was owned.
      switch (param.getConvention()) {
      case ParameterConvention::Direct_Owned:
        SGF.emitManagedRValueWithCleanup(v);
        break;

      case ParameterConvention::Direct_Guaranteed:
      case ParameterConvention::Direct_Unowned:
        break;
        
      case ParameterConvention::Indirect_In:
      case ParameterConvention::Indirect_In_Constant:
      case ParameterConvention::Indirect_In_Guaranteed:
      case ParameterConvention::Indirect_Inout:
      case ParameterConvention::Indirect_InoutAliasable:
        llvm_unreachable(""indirect params to blocks not supported"");
      }
      
      SILValue blockCopy = SGF.B.createCopyBlock(loc, v);
      mv = SGF.emitManagedRValueWithCleanup(blockCopy);
    } else {
      mv = emitManagedParameter(SGF, loc, param, v);
    }

    CanType formalBridgedType = bridgedParamTypes[i];
    CanType formalNativeType = nativeParamTypes[i];
    SILType loweredNativeTy = funcTy->getParameters()[i].getSILStorageType();
    
    args.push_back(SGF.emitBridgedToNativeValue(loc, mv, formalBridgedType,
                                                formalNativeType,
                                                loweredNativeTy));
  }

  auto init = indirectResult
                ? SGF.useBufferAsTemporary(indirectResult,
                                SGF.getTypeLowering(indirectResult->getType()))
                : nullptr;

  CanType formalNativeResultType = formalFuncType.getResult();
  CanType formalBridgedResultType = formalBlockType.getResult();

  bool canEmitIntoInit =
    (indirectResult &&
     indirectResult->getType()
       == SGF.getLoweredType(formalNativeResultType).getAddressType());

  // Call the native function.
  SGFContext C(canEmitIntoInit ? init.get() : nullptr);
  ManagedValue result = SGF.emitMonomorphicApply(loc, fn, args,
                                                 formalNativeResultType,
                                                 formalNativeResultType,
                                                 ApplyOptions::None,
                                                 None, None, C)
    .getAsSingleValue(SGF, loc);

  // Bridge the result back to ObjC.
  if (!canEmitIntoInit) {
    result = SGF.emitNativeToBridgedValue(loc, result,
                                          formalNativeResultType,
                                          formalBridgedResultType,
                                          blockResultTy,
                                          SGFContext(init.get()));
  }

  SILValue resultVal;

  // If we have an indirect result, make sure the result is there.
  if (indirectResult) {
    if (!result.isInContext()) {
      init->copyOrInitValueInto(SGF, loc, result, /*isInit*/ true);
      init->finishInitialization(SGF);
    }
    init->getManagedAddress().forward(SGF);
    resultVal = SGF.B.createTuple(loc, {});
  } else {
    // Otherwise, return the result at +1.
    resultVal = result.forward(SGF);
  }

  scope.pop();

  SGF.B.createReturn(loc, resultVal);
}

/// Bridge a native function to a block with a thunk.
ManagedValue SILGenFunction::emitFuncToBlock(SILLocation loc,
                                             ManagedValue fn,
                                             CanAnyFunctionType funcType,
                                             CanAnyFunctionType blockType,
                                             CanSILFunctionType loweredBlockTy){
  auto loweredFuncTy = fn.getType().castTo<SILFunctionType>();

  // Build the invoke function signature. The block will capture the original
  // function value.
  auto fnInterfaceTy = cast<SILFunctionType>(
    loweredFuncTy->mapTypeOutOfContext()->getCanonicalType());
  auto blockInterfaceTy = cast<SILFunctionType>(
    loweredBlockTy->mapTypeOutOfContext()->getCanonicalType());

  assert(!blockInterfaceTy->isCoroutine());

  auto storageTy = SILBlockStorageType::get(loweredFuncTy);
  auto storageInterfaceTy = SILBlockStorageType::get(fnInterfaceTy);

  // Build the invoke function type.
  SmallVector<SILParameterInfo, 4> params;
  params.push_back(SILParameterInfo(storageInterfaceTy,
                                 ParameterConvention::Indirect_InoutAliasable));
  std::copy(blockInterfaceTy->getParameters().begin(),
            blockInterfaceTy->getParameters().end(),
            std::back_inserter(params));

  auto extInfo =
      SILFunctionType::ExtInfo()
        .withRepresentation(SILFunctionType::Representation::CFunctionPointer);

  CanGenericSignature genericSig;
  GenericEnvironment *genericEnv = nullptr;
  SubstitutionList subs;
  if (funcType->hasArchetype() || blockType->hasArchetype()) {
    genericSig = F.getLoweredFunctionType()->getGenericSignature();
    genericEnv = F.getGenericEnvironment();

    subs = F.getForwardingSubstitutions();

    // The block invoke function must be pseudogeneric. This should be OK for now
    // since a bridgeable function's parameters and returns should all be
    // trivially representable in ObjC so not need to exercise the type metadata.
    //
    // Ultimately we may need to capture generic parameters in block storage, but
    // that will require a redesign of the interface to support dependent-layout
    // context. Currently we don't capture anything directly into a block but a
    // Swift closure, but that's totally dumb.
    if (genericSig)
      extInfo = extInfo.withIsPseudogeneric();
  }

  auto invokeTy = SILFunctionType::get(
      genericSig, extInfo, SILCoroutineKind::None,
      ParameterConvention::Direct_Unowned, params, 
      /*yields*/ {}, blockInterfaceTy->getResults(),
      blockInterfaceTy->getOptionalErrorResult(), getASTContext());

  // Create the invoke function. Borrow the mangling scheme from reabstraction
  // thunks, which is what we are in spirit.
  auto thunk = SGM.getOrCreateReabstractionThunk(invokeTy,
                                                 loweredFuncTy,
                                                 loweredBlockTy,
                                                 F.isSerialized());

  // Build it if necessary.
  if (thunk->empty()) {
    thunk->setGenericEnvironment(genericEnv);
    SILGenFunction thunkSGF(SGM, *thunk);
    auto loc = RegularLocation::getAutoGeneratedLocation();
    buildFuncToBlockInvokeBody(thunkSGF, loc, funcType, blockType,
                               loweredFuncTy, loweredBlockTy, storageTy);
  }

  // Form the block on the stack.
  auto storageAddrTy = SILType::getPrimitiveAddressType(storageTy);
  auto storage = emitTemporaryAllocation(loc, storageAddrTy);
  auto capture = B.createProjectBlockStorage(loc, storage);
  B.createStore(loc, fn, capture, StoreOwnershipQualifier::Init);
  auto invokeFn = B.createFunctionRef(loc, thunk);
  
  auto stackBlock = B.createInitBlockStorageHeader(loc, storage, invokeFn,
                              SILType::getPrimitiveObjectType(loweredBlockTy),
                                                   subs);

  // Copy the block so we have an independent heap object we can hand off.
  auto heapBlock = B.createCopyBlock(loc, stackBlock);
  return emitManagedRValueWithCleanup(heapBlock);
}

static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &SGF,
                                                         SILLocation loc,
                                                         ManagedValue v,
                                                         CanType nativeType,
                                                         CanType bridgedType,
                                                      SILType loweredBridgedTy,
                                                         SGFContext C) {
  assert(loweredBridgedTy.isObject());
  if (v.getType().getObjectType() == loweredBridgedTy)
    return v;

  // If the input is a native type with a bridged mapping, convert it.
#define BRIDGE_TYPE(BridgedModule,BridgedType, NativeModule,NativeType,Opt) \\
  if (nativeType == SGF.SGM.Types.get##NativeType##Type()                   \\
      && bridgedType == SGF.SGM.Types.get##BridgedType##Type()) {           \\
    return emitBridge##NativeType##To##BridgedType(SGF, loc, v);            \\
  }
#include ""swift/SIL/BridgedTypes.def""

  // Bridge thick to Objective-C metatypes.
  if (auto bridgedMetaTy = dyn_cast<AnyMetatypeType>(bridgedType)) {
    if (bridgedMetaTy->hasRepresentation() &&
        bridgedMetaTy->getRepresentation() == MetatypeRepresentation::ObjC) {
      SILValue native = SGF.B.emitThickToObjCMetatype(loc, v.getValue(),
                                                      loweredBridgedTy);
      // *NOTE*: ObjCMetatypes are trivial types. They only gain ARC semantics
      // when they are converted to an object via objc_metatype_to_object.
      assert(!v.hasCleanup() &&
             ""Metatypes are trivial and thus should not have cleanups"");
      return ManagedValue::forUnmanaged(native);
    }
  }

  // Bridge native functions to blocks.
  auto bridgedFTy = dyn_cast<AnyFunctionType>(bridgedType);
  if (bridgedFTy && bridgedFTy->getRepresentation()
                      == AnyFunctionType::Representation::Block) {
    auto nativeFTy = cast<AnyFunctionType>(nativeType);

    if (nativeFTy->getRepresentation()
          != AnyFunctionType::Representation::Block)
      return SGF.emitFuncToBlock(loc, v, nativeFTy, bridgedFTy,
                                 loweredBridgedTy.castTo<SILFunctionType>());
  }

  // If the native type conforms to _ObjectiveCBridgeable, use its
  // _bridgeToObjectiveC witness.
  if (auto conformance =
          SGF.SGM.getConformanceToObjectiveCBridgeable(loc, nativeType)) {
    if (auto result = emitBridgeNativeToObjectiveC(SGF, loc, v, nativeType,
                                                   bridgedType, conformance))
      return *result;

    assert(SGF.SGM.getASTContext().Diags.hadAnyError() &&
           ""Bridging code should have complained"");
    return SGF.emitUndef(loc, bridgedType);
  }

  // Bridge Error, or types that conform to it, to NSError.
  if (shouldBridgeThroughError(SGF.SGM, nativeType, bridgedType)) {
    auto errorTy = SGF.SGM.Types.getNSErrorType();
    auto error = SGF.emitNativeToBridgedError(loc, v, nativeType, errorTy);
    if (errorTy != bridgedType) {
      error = emitUnabstractedCast(SGF, loc, error, errorTy, bridgedType);
    }
    return error;
  }

  // Fall back to dynamic Any-to-id bridging.
  // The destination type should be AnyObject in this case.
  assert(bridgedType->isEqual(SGF.getASTContext().getAnyObjectType()));

  // Blocks bridge to id with a cast under ObjCInterop.
  if (auto nativeFnType = dyn_cast<AnyFunctionType>(nativeType)) {
    if (nativeFnType->getRepresentation() ==
          FunctionTypeRepresentation::Block &&
        SGF.getASTContext().LangOpts.EnableObjCInterop) {
      return SGF.B.createBlockToAnyObject(loc, v, loweredBridgedTy);
    }
  }

  // If the input argument is known to be an existential, save the runtime
  // some work by opening it.
  if (nativeType->isExistentialType()) {
    auto openedType = ArchetypeType::getOpened(nativeType);

    auto openedExistential = SGF.emitOpenExistential(
        loc, v, openedType, SGF.getLoweredType(openedType), AccessKind::Read);

    v = SGF.manageOpaqueValue(openedExistential, loc, SGFContext());
    nativeType = openedType;
  }

  // Call into the stdlib intrinsic.
  if (auto bridgeAnything =
        SGF.getASTContext().getBridgeAnythingToObjectiveC(nullptr)) {
    auto *genericSig = bridgeAnything->getGenericSignature();
    auto subMap = genericSig->getSubstitutionMap(
      [&](SubstitutableType *t) -> Type {
        return nativeType;
      },
      MakeAbstractConformanceForGenericType());

    // The intrinsic takes a T; reabstract to the generic abstraction
    // pattern.
    v = SGF.emitSubstToOrigValue(loc, v, AbstractionPattern::getOpaque(),
                                 nativeType);

    // Put the value into memory if necessary.
    assert(v.getType().isTrivial(SGF.SGM.M) || v.hasCleanup());
    SILModuleConventions silConv(SGF.SGM.M);
    // bridgeAnything always takes an indirect argument as @in.
    // Since we don't have the SIL type here, check the current SIL stage/mode
    // to determine the convention.
    if (v.getType().isObject() && silConv.useLoweredAddresses()) {
      auto tmp = SGF.emitTemporaryAllocation(loc, v.getType());
      v.forwardInto(SGF, loc, tmp);
      v = SGF.emitManagedBufferWithCleanup(tmp);
    }
    return SGF.emitApplyOfLibraryIntrinsic(loc, bridgeAnything, subMap, v, C)
              .getAsSingleValue(SGF, loc);
  }
  
  // Shouldn't get here unless the standard library is busted.
  return SGF.emitUndef(loc, loweredBridgedTy);
}

static ManagedValue emitNativeToCBridgedValue(SILGenFunction &SGF,
                                              SILLocation loc,
                                              ManagedValue v,
                                              CanType nativeType,
                                              CanType bridgedType,
                                              SILType loweredBridgedTy,
                                              SGFContext C = SGFContext()) {
  SILType loweredNativeTy = v.getType();
  if (loweredNativeTy.getObjectType() == loweredBridgedTy.getObjectType())
    return v;

  CanType bridgedObjectType = bridgedType.getOptionalObjectType();
  CanType nativeObjectType = nativeType.getOptionalObjectType();

  // Check for optional-to-optional conversions.
  if (bridgedObjectType && nativeObjectType) {
    auto helper = [&](SILGenFunction &SGF, SILLocation loc,
                      ManagedValue v, SILType loweredBridgedObjectTy,
                      SGFContext C) {
      return emitNativeToCBridgedValue(SGF, loc, v, nativeObjectType,
                                       bridgedObjectType,
                                       loweredBridgedObjectTy, C);
    };
    return SGF.emitOptionalToOptional(loc, v, loweredBridgedTy, helper, C);
  }
  
  // Check if we need to wrap the bridged result in an optional.
  if (bridgedObjectType) {
    auto helper = [&](SILGenFunction &SGF, SILLocation loc, SGFContext C) {
      auto loweredBridgedObjectTy = loweredBridgedTy.getOptionalObjectType();
      return emitNativeToCBridgedValue(SGF, loc, v, nativeType,
                                       bridgedObjectType,
                                       loweredBridgedObjectTy, C);
    };
    return SGF.emitOptionalSome(loc, loweredBridgedTy, helper, C);
  }
  
  return emitNativeToCBridgedNonoptionalValue(SGF, loc, v, nativeType,
                                              bridgedType, loweredBridgedTy, C);
}

ManagedValue SILGenFunction::emitNativeToBridgedValue(SILLocation loc,
                                                      ManagedValue v,
                                                      CanType nativeTy,
                                                      CanType bridgedTy,
                                                      SILType loweredBridgedTy,
                                                      SGFContext C) {
  loweredBridgedTy = loweredBridgedTy.getObjectType();
  return emitNativeToCBridgedValue(*this, loc, v, nativeTy, bridgedTy,
                                   loweredBridgedTy, C);
}

static void buildBlockToFuncThunkBody(SILGenFunction &SGF,
                                      SILLocation loc,
                                      CanAnyFunctionType formalBlockTy,
                                      CanAnyFunctionType formalFuncTy,
                                      CanSILFunctionType blockTy,
                                      CanSILFunctionType funcTy) {
  // Collect the native arguments, which should all be +1.
  Scope scope(SGF.Cleanups, CleanupLocation::get(loc));

  // Make sure we lower the component types of the formal block type.
  formalBlockTy = getBridgedBlockType(SGF.SGM, formalBlockTy);

  assert(blockTy->getNumParameters() == funcTy->getNumParameters()
         && ""block and function types don't match"");

  SmallVector<ManagedValue, 4> args;
  SILBasicBlock *entry = &*SGF.F.begin();

  SILFunctionConventions fnConv(funcTy, SGF.SGM.M);

  // Set up the indirect result slot.
  SILValue indirectResult;
  if (funcTy->getNumResults() != 0) {
    auto result = funcTy->getSingleResult();
    if (result.getConvention() == ResultConvention::Indirect) {
      SILType resultTy = fnConv.getSILType(result);
      indirectResult = entry->createFunctionArgument(resultTy);
    }
  }

  auto formalBlockParams = expandTupleTypes(formalBlockTy.getParams());
  auto formalFuncParams = expandTupleTypes(formalFuncTy.getParams());
  assert(formalBlockParams.size() == blockTy->getNumParameters());
  assert(formalFuncParams.size() == funcTy->getNumParameters());

  // Create the arguments for the call.
  for (unsigned i : indices(funcTy->getParameters())) {
    auto &param = funcTy->getParameters()[i];
    CanType formalBlockParamTy = formalBlockParams[i];
    CanType formalFuncParamTy = formalFuncParams[i];

    auto paramTy = fnConv.getSILType(param);
    SILValue v = entry->createFunctionArgument(paramTy);

    // First get the managed parameter for this function.
    auto mv = emitManagedParameter(SGF, loc, param, v);

    SILType loweredBlockArgTy = blockTy->getParameters()[i].getSILStorageType();

    // Then bridge the native value to its bridged variant.
    mv = SGF.emitNativeToBridgedValue(loc, mv, formalFuncParamTy,
                                      formalBlockParamTy, loweredBlockArgTy);

    // Finally change ownership if we need to. We do not need to care about the
    // case of a +1 parameter being passed to a +0 function since +1 parameters
    // can be ""instantaneously"" borrowed at the call site.
    if (blockTy->getParameters()[i].isConsumed()) {
      mv = mv.ensurePlusOne(SGF, loc);
    }
    args.push_back(mv);
  }

  // Add the block argument.
  SILValue blockV =
      entry->createFunctionArgument(SILType::getPrimitiveObjectType(blockTy));
  ManagedValue block = ManagedValue::forUnmanaged(blockV);

  CanType formalResultType = formalFuncTy.getResult();

  auto init = indirectResult
                ? SGF.useBufferAsTemporary(indirectResult,
                                SGF.getTypeLowering(indirectResult->getType()))
                : nullptr;

  // Call the block.
  ManagedValue result = SGF.emitMonomorphicApply(loc, block, args,
                           formalBlockTy.getResult(),
                           formalResultType,
                           ApplyOptions::None,
                           /*override CC*/ SILFunctionTypeRepresentation::Block,
                           /*foreign error*/ None,
                           SGFContext(init.get()))
    .getAsSingleValue(SGF, loc);

  SILValue r;

  // If we have an indirect result, make sure the result is there.
  if (indirectResult) {
    if (!result.isInContext()) {
      init->copyOrInitValueInto(SGF, loc, result, /*isInit*/ true);
      init->finishInitialization(SGF);
    }
    init->getManagedAddress().forward(SGF);
    r = SGF.B.createTuple(loc, fnConv.getSILResultType(), ArrayRef<SILValue>());

    // Otherwise, return the result at +1.
  } else {
    r = result.forward(SGF);
  }

  scope.pop();

  SGF.B.createReturn(loc, r);

  // Finally, verify the thunk for SIL invariants.
  SGF.F.verify();
}

/// Bridge a native function to a block with a thunk.
ManagedValue
SILGenFunction::emitBlockToFunc(SILLocation loc,
                                ManagedValue block,
                                CanAnyFunctionType blockType,
                                CanAnyFunctionType funcType,
                                CanSILFunctionType loweredFuncTy) {
  // Declare the thunk.
  auto loweredBlockTy = block.getType().castTo<SILFunctionType>();

  SubstitutionMap contextSubs, interfaceSubs;
  GenericEnvironment *genericEnv = nullptr;

  // These two are not used here -- but really, bridging thunks
  // should be emitted using the formal AST type, not the lowered
  // type
  CanType inputSubstType, outputSubstType;

  auto loweredFuncTyWithoutNoEscape = adjustFunctionType(
      loweredFuncTy, loweredFuncTy->getExtInfo().withNoEscape(false),
      loweredFuncTy->getWitnessMethodConformanceOrNone());

  auto thunkTy = buildThunkType(loweredBlockTy, loweredFuncTyWithoutNoEscape,
                                inputSubstType, outputSubstType,
                                genericEnv, interfaceSubs);

  auto thunk = SGM.getOrCreateReabstractionThunk(thunkTy,
                                                 loweredBlockTy,
                                                 loweredFuncTyWithoutNoEscape,
                                                 F.isSerialized());

  // Build it if necessary.
  if (thunk->empty()) {
    SILGenFunction thunkSGF(SGM, *thunk);
    thunk->setGenericEnvironment(genericEnv);
    auto loc = RegularLocation::getAutoGeneratedLocation();
    buildBlockToFuncThunkBody(thunkSGF, loc, blockType, funcType,
                              loweredBlockTy, loweredFuncTyWithoutNoEscape);
  }

  CanSILFunctionType substFnTy = thunkTy;

  SmallVector<Substitution, 4> subs;
  if (auto genericSig = thunkTy->getGenericSignature()) {
    genericSig->getSubstitutions(interfaceSubs, subs);
    substFnTy = thunkTy->substGenericArgs(F.getModule(),
                                          interfaceSubs);
  }

  // Create it in the current function.
  auto thunkValue = B.createFunctionRef(loc, thunk);
  ManagedValue thunkedFn = B.createPartialApply(
      loc, thunkValue, SILType::getPrimitiveObjectType(substFnTy), subs,
      block,
      SILType::getPrimitiveObjectType(loweredFuncTyWithoutNoEscape));

  if (!loweredFuncTy->isNoEscape()) {
    return thunkedFn;
  }

  // Handle the escaping to noescape conversion.
  assert(loweredFuncTy->isNoEscape());
  return B.createConvertEscapeToNoEscape(
      loc, thunkedFn, SILType::getPrimitiveObjectType(loweredFuncTy), false);
}

static ManagedValue emitCBridgedToNativeValue(SILGenFunction &SGF,
                                              SILLocation loc,
                                              ManagedValue v,
                                              CanType bridgedType,
                                              CanType nativeType,
                                              SILType loweredNativeTy,
                                              bool isCallResult,
                                              SGFContext C) {
  assert(loweredNativeTy.isObject());
  SILType loweredBridgedTy = v.getType();
  if (loweredNativeTy == loweredBridgedTy.getObjectType())
    return v;

  if (auto nativeObjectType = nativeType.getOptionalObjectType()) {
    auto bridgedObjectType = bridgedType.getOptionalObjectType();

    // Optional injection.
    if (!bridgedObjectType) {
      auto helper = [&](SILGenFunction &SGF, SILLocation loc, SGFContext C) {
        auto loweredNativeObjectTy = loweredNativeTy.getOptionalObjectType();
        return emitCBridgedToNativeValue(SGF, loc, v, bridgedType,
                                         nativeObjectType,
                                         loweredNativeObjectTy,
                                         isCallResult, C);
      };
      return SGF.emitOptionalSome(loc, loweredNativeTy, helper, C);
    }

    // Optional-to-optional.
    auto helper =
        [=](SILGenFunction &SGF, SILLocation loc, ManagedValue v,
            SILType loweredNativeObjectTy, SGFContext C) {
      return emitCBridgedToNativeValue(SGF, loc, v, bridgedObjectType,
                                       nativeObjectType, loweredNativeObjectTy,
                                       isCallResult, C);
    };
    return SGF.emitOptionalToOptional(loc, v, loweredNativeTy, helper, C);
  }

  // Bridge Bool to ObjCBool or DarwinBoolean when requested.
  if (nativeType == SGF.SGM.Types.getBoolType()) {
    if (bridgedType == SGF.SGM.Types.getObjCBoolType()) {
      return emitBridgeForeignBoolToBool(SGF, loc, v,
                                         SGF.SGM.getObjCBoolToBoolFn());
    }
    if (bridgedType == SGF.SGM.Types.getDarwinBooleanType()) {
      return emitBridgeForeignBoolToBool(SGF, loc, v,
                                         SGF.SGM.getDarwinBooleanToBoolFn());
    }
  }

  // Bridge Objective-C to thick metatypes.
  if (isa<AnyMetatypeType>(nativeType)) {
    auto bridgedMetaTy = cast<AnyMetatypeType>(bridgedType);
    if (bridgedMetaTy->hasRepresentation() &&
        bridgedMetaTy->getRepresentation() == MetatypeRepresentation::ObjC) {
      SILValue native =
        SGF.B.emitObjCToThickMetatype(loc, v.getValue(), loweredNativeTy);
      // *NOTE*: ObjCMetatypes are trivial types. They only gain ARC semantics
      // when they are converted to an object via objc_metatype_to_object.
      assert(!v.hasCleanup() && ""Metatypes are trivial and should not have ""
                                ""cleanups"");
      return ManagedValue::forUnmanaged(native);
    }
  }

  // Bridge blocks back into native function types.
  if (auto nativeFTy = dyn_cast<AnyFunctionType>(nativeType)) {
    auto bridgedFTy = cast<AnyFunctionType>(bridgedType);
    if (bridgedFTy->getRepresentation()
          == AnyFunctionType::Representation::Block
        && nativeFTy->getRepresentation()
          != AnyFunctionType::Representation::Block) {
      return SGF.emitBlockToFunc(loc, v, bridgedFTy, nativeFTy,
                                 loweredNativeTy.castTo<SILFunctionType>());
    }
  }

  // Bridge via _ObjectiveCBridgeable.
  if (auto conformance =
        SGF.SGM.getConformanceToObjectiveCBridgeable(loc, nativeType)) {
    if (auto result = emitBridgeObjectiveCToNative(SGF, loc, v, bridgedType,
                                                   conformance))
      return *result;

    assert(SGF.SGM.getASTContext().Diags.hadAnyError() &&
           ""Bridging code should have complained"");
    return SGF.emitUndef(loc, nativeType);
  }

  // id-to-Any bridging.
  if (nativeType->isAny()) {
    // If this is not a call result, use the normal erasure logic.
    if (!isCallResult) {
      return SGF.emitTransformedValue(loc, v, bridgedType, nativeType, C);
    }

    // Otherwise, we use more complicated logic that handles results that
    // were unexpetedly null.

    assert(bridgedType.isAnyClassReferenceType());

    // Convert to AnyObject if necessary.
    CanType anyObjectTy =
      SGF.getASTContext().getAnyObjectType()->getCanonicalType();
    if (bridgedType != anyObjectTy) {
      v = SGF.emitTransformedValue(loc, v, bridgedType, anyObjectTy);
    }

    // TODO: Ever need to handle +0 values here?
    assert(v.hasCleanup());

    // Use a runtime call to bridge the AnyObject to Any. We do this instead of
    // a simple AnyObject-to-Any upcast because the ObjC API may have returned
    // a null object in spite of its annotation.
    
    // Bitcast to Optional. This provides a barrier to the optimizer to prevent
    // it from attempting to eliminate null checks.
    auto optionalBridgedTy = SILType::getOptionalType(loweredBridgedTy);
    auto optionalMV =
      SGF.B.createUncheckedBitCast(loc, v, optionalBridgedTy);
    return SGF.emitApplyOfLibraryIntrinsic(loc,
                           SGF.getASTContext().getBridgeAnyObjectToAny(nullptr),
                           SubstitutionMap(), optionalMV, C)
              .getAsSingleValue(SGF, loc);
  }

  // Bridge NSError to Error.
  if (bridgedType == SGF.SGM.Types.getNSErrorType())
    return SGF.emitBridgedToNativeError(loc, v);

  return v;
}

ManagedValue SILGenFunction::emitBridgedToNativeValue(SILLocation loc,
                                                      ManagedValue v,
                                                      CanType bridgedType,
                                                      CanType nativeType,
                                                      SILType loweredNativeTy,
                                                      SGFContext C,
                                                      bool isCallResult) {
  loweredNativeTy = loweredNativeTy.getObjectType();
  return emitCBridgedToNativeValue(*this, loc, v, bridgedType, nativeType,
                                   loweredNativeTy, isCallResult, C);
}

/// Bridge a possibly-optional foreign error type to Error.
ManagedValue SILGenFunction::emitBridgedToNativeError(SILLocation loc,
                                                  ManagedValue bridgedError) {
  // If the incoming error is non-optional, just do an existential erasure.
  CanType bridgedErrorTy = bridgedError.getType().getSwiftRValueType();
  if (!bridgedErrorTy.getOptionalObjectType()) {
    auto nativeErrorTy = SILType::getExceptionType(getASTContext());

    auto conformance = SGM.getNSErrorConformanceToError();
    if (!conformance) return emitUndef(loc, nativeErrorTy);
    ProtocolConformanceRef conformanceArray[] = {
      ProtocolConformanceRef(conformance)
    };
    auto conformances = getASTContext().AllocateCopy(conformanceArray);

    return B.createInitExistentialRef(loc, nativeErrorTy, bridgedErrorTy,
                                      bridgedError, conformances);
  }

  // Otherwise, we need to call a runtime function to potential substitute
  // a standard error for a nil NSError.
  auto bridgeFn = emitGlobalFunctionRef(loc, SGM.getNSErrorToErrorFn());
  auto bridgeFnType = bridgeFn->getType().castTo<SILFunctionType>();
  SILFunctionConventions bridgeFnConv(bridgeFnType, SGM.M);
  assert(bridgeFnType->getNumResults() == 1);
  assert(bridgeFnType->getResults()[0].getConvention()
         == ResultConvention::Owned);
  auto nativeErrorType = bridgeFnConv.getSILType(bridgeFnType->getResults()[0]);

  SILValue arg;
  if (SGM.M.getOptions().EnableGuaranteedNormalArguments) {
    assert(bridgeFnType->getParameters()[0].getConvention() ==
           ParameterConvention::Direct_Guaranteed);
    arg = bridgedError.getValue();
  } else {
    assert(bridgeFnType->getParameters()[0].getConvention() ==
           ParameterConvention::Direct_Owned);
    arg = bridgedError.forward(*this);
  }

  SILValue nativeError = B.createApply(loc, bridgeFn, bridgeFn->getType(),
                                       nativeErrorType, {}, arg);
  return emitManagedRValueWithCleanup(nativeError);
}

/// Bridge Error to a foreign error type.
ManagedValue SILGenFunction::emitNativeToBridgedError(SILLocation loc,
                                                      ManagedValue nativeError,
                                                      CanType nativeType,
                                                      CanType bridgedErrorType){
  // Handle injections into optional.
  if (auto bridgedObjectType = bridgedErrorType.getOptionalObjectType()) {
    auto loweredBridgedOptionalTy =
      SILType::getPrimitiveObjectType(bridgedErrorType);
    return emitOptionalSome(
        loc, loweredBridgedOptionalTy,
        [&](SILGenFunction &SGF, SILLocation loc, SGFContext C) {
          SILType loweredBridgedObjectTy =
              loweredBridgedOptionalTy.getOptionalObjectType();
          return emitNativeToBridgedValue(loc, nativeError, nativeType,
                                          bridgedObjectType,
                                          loweredBridgedObjectTy);
        });
  }

  assert(bridgedErrorType == SGM.Types.getNSErrorType() &&
         ""only handling NSError for now"");

  // The native error might just be a value of a type that conforms to
  // Error.  This should be a subtyping or erasure conversion of the sort
  // that we can do automatically.
  // FIXME: maybe we should use a different entrypoint for this case, to
  // avoid the code size and performance overhead of forming the box?
  nativeError = emitUnabstractedCast(*this, loc, nativeError, nativeType,
                                     getASTContext().getExceptionType());

  auto bridgeFn = emitGlobalFunctionRef(loc, SGM.getErrorToNSErrorFn());
  auto bridgeFnType = bridgeFn->getType().castTo<SILFunctionType>();
  SILFunctionConventions bridgeFnConv(bridgeFnType, SGM.M);
  assert(bridgeFnType->getNumResults() == 1);
  assert(bridgeFnType->getResults()[0].getConvention()
         == ResultConvention::Owned);
  auto loweredBridgedErrorType =
    bridgeFnConv.getSILType(bridgeFnType->getResults()[0]);

  SILValue arg;
  if (SGM.M.getOptions().EnableGuaranteedNormalArguments) {
    assert(bridgeFnType->getParameters()[0].getConvention() ==
           ParameterConvention::Direct_Guaranteed);
    arg = nativeError.getValue();
  } else {
    assert(bridgeFnType->getParameters()[0].getConvention() ==
           ParameterConvention::Direct_Owned);
    arg = nativeError.forward(*this);
  }

  SILValue bridgedError = B.createApply(loc, bridgeFn, bridgeFn->getType(),
                                        loweredBridgedErrorType, {}, arg);
  return emitManagedRValueWithCleanup(bridgedError);
}

//===----------------------------------------------------------------------===//
// ObjC method thunks
//===----------------------------------------------------------------------===//

static SILValue emitBridgeReturnValue(SILGenFunction &SGF,
                                      SILLocation loc,
                                      SILValue result,
                                      CanType formalNativeTy,
                                      CanType formalBridgedTy,
                                      SILType loweredBridgedTy) {
  Scope scope(SGF.Cleanups, CleanupLocation::get(loc));

  ManagedValue native = SGF.emitManagedRValueWithCleanup(result);
  ManagedValue bridged =
    SGF.emitNativeToBridgedValue(loc, native, formalNativeTy, formalBridgedTy,
                                 loweredBridgedTy);
  return bridged.forward(SGF);
}

/// Take an argument at +0 and bring it to +1.
static SILValue emitObjCUnconsumedArgument(SILGenFunction &SGF,
                                           SILLocation loc,
                                           SILValue arg) {
  auto &lowering = SGF.getTypeLowering(arg->getType());
  // If address-only, make a +1 copy and operate on that.
  if (lowering.isAddressOnly()) {
    auto tmp = SGF.emitTemporaryAllocation(loc, arg->getType().getObjectType());
    SGF.B.createCopyAddr(loc, arg, tmp, IsNotTake, IsInitialization);
    return tmp;
  }

  return lowering.emitCopyValue(SGF.B, loc, arg);
}

static CanAnyFunctionType substGenericArgs(CanAnyFunctionType fnType,
                                           const SubstitutionList &subs) {
  if (auto genericFnType = dyn_cast<GenericFunctionType>(fnType)) {
    return cast<FunctionType>(genericFnType->substGenericArgs(subs)
                                           ->getCanonicalType());
  }
  return fnType;
}

/// Bridge argument types and adjust retain count conventions for an ObjC thunk.
static SILFunctionType *emitObjCThunkArguments(SILGenFunction &SGF,
                                               SILLocation loc,
                                               SILDeclRef thunk,
                                               SmallVectorImpl<SILValue> &args,
                                               SILValue &foreignErrorSlot,
                              Optional<ForeignErrorConvention> &foreignError,
                                               CanType &nativeFormalResultTy,
                                               CanType &bridgedFormalResultTy) {
  SILDeclRef native = thunk.asForeign(false);

  auto subs = SGF.F.getForwardingSubstitutions();

  auto objcInfo = SGF.SGM.Types.getConstantInfo(thunk);
  auto objcFnTy = objcInfo.SILFnType->substGenericArgs(SGF.SGM.M, subs);
  auto objcFormalFnTy = substGenericArgs(objcInfo.LoweredType, subs);

  auto swiftInfo = SGF.SGM.Types.getConstantInfo(native);
  auto swiftFnTy = swiftInfo.SILFnType->substGenericArgs(SGF.SGM.M, subs);
  auto swiftFormalFnTy = substGenericArgs(swiftInfo.LoweredType, subs);
  SILFunctionConventions swiftConv(swiftFnTy, SGF.SGM.M);

  // We must have the same context archetypes as the unthunked function.
  assert(objcInfo.GenericEnv == swiftInfo.GenericEnv);

  SmallVector<ManagedValue, 8> bridgedArgs;
  bridgedArgs.reserve(objcFnTy->getParameters().size());

  SILFunction *orig = SGF.SGM.getFunction(native, NotForDefinition);

  // Find the foreign error convention if we have one.
  if (orig->getLoweredFunctionType()->hasErrorResult()) {
    auto func = cast<AbstractFunctionDecl>(thunk.getDecl());
    foreignError = func->getForeignErrorConvention();
    assert(foreignError && ""couldn't find foreign error convention!"");
  }

  // We don't know what to do with indirect results from the Objective-C side.
  assert(objcFnTy->getNumIndirectFormalResults() == 0
         && ""Objective-C methods cannot have indirect results"");

  auto bridgedFormalTypes = expandTupleTypes(objcFormalFnTy.getParams());
  bridgedFormalResultTy = objcFormalFnTy.getResult();

  auto nativeFormalTypes = expandTupleTypes(swiftFormalFnTy.getParams());
  nativeFormalResultTy = swiftFormalFnTy.getResult();

  // Emit the other arguments, taking ownership of arguments if necessary.
  auto inputs = objcFnTy->getParameters();
  auto nativeInputs = swiftFnTy->getParameters();
  assert(nativeInputs.size() == bridgedFormalTypes.size());
  assert(nativeInputs.size() == nativeFormalTypes.size());
  assert(inputs.size() ==
           nativeInputs.size() + unsigned(foreignError.hasValue()));
  for (unsigned i = 0, e = inputs.size(); i < e; ++i) {
    SILType argTy = SGF.getSILType(inputs[i]);
    SILValue arg = SGF.F.begin()->createFunctionArgument(argTy);

    // If this parameter is the foreign error slot, pull it out.
    // It does not correspond to a native argument.
    if (foreignError && i == foreignError->getErrorParameterIndex()) {
      foreignErrorSlot = arg;
      continue;
    }

    // If the argument is a block, copy it.
    if (argTy.isBlockPointerCompatible()) {
      auto copy = SGF.B.createCopyBlock(loc, arg);
      // If the argument is consumed, we're still responsible for releasing the
      // original.
      if (inputs[i].isConsumed())
        SGF.emitManagedRValueWithCleanup(arg);
      arg = copy;
    }
    // Convert the argument to +1 if necessary.
    else if (!inputs[i].isConsumed()) {
      arg = emitObjCUnconsumedArgument(SGF, loc, arg);
    }

    auto managedArg = SGF.emitManagedRValueWithCleanup(arg);

    bridgedArgs.push_back(managedArg);
  }

  assert(bridgedArgs.size() + unsigned(foreignError.hasValue())
           == objcFnTy->getParameters().size() &&
         ""objc inputs don't match number of arguments?!"");
  assert(bridgedArgs.size() == swiftFnTy->getParameters().size() &&
         ""swift inputs don't match number of arguments?!"");
  assert((foreignErrorSlot || !foreignError) &&
         ""didn't find foreign error slot"");

  // Bridge the input types.

  // FIXME: We really want alloc_stacks to outlive this scope, because
  // bridging id-to-Any requires allocating an Any which gets passed to
  // the native entry point.

  // Scope scope(gen.Cleanups, CleanupLocation::get(loc));

  assert(bridgedArgs.size() == nativeInputs.size());
  for (unsigned i = 0, size = bridgedArgs.size(); i < size; ++i) {
    // Consider the bridged values to be ""call results"" since they're coming
    // from potentially nil-unsound ObjC callers.
    ManagedValue native =
      SGF.emitBridgedToNativeValue(loc,
                        bridgedArgs[i],
                        bridgedFormalTypes[i],
                        nativeFormalTypes[i],
                        swiftFnTy->getParameters()[i].getSILStorageType(),
                        SGFContext(),
                        /*isCallResult*/ true);
    SILValue argValue;

    if (nativeInputs[i].isConsumed()) {
      argValue = native.forward(SGF);
    } else if (nativeInputs[i].isGuaranteed()) {
      argValue = native.borrow(SGF, loc).getUnmanagedValue();
    } else {
      argValue = native.getValue();
    }

    args.push_back(argValue);
  }

  return objcFnTy;
}

void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
  assert(thunk.isForeign);
  SILDeclRef native = thunk.asForeign(false);
  auto nativeInfo = getConstantInfo(native);
  auto subs = F.getForwardingSubstitutions();
  auto substTy = nativeInfo.SILFnType->substGenericArgs(SGM.M, subs);
  SILType substSILTy = SILType::getPrimitiveObjectType(substTy);
  SILFunctionConventions substConv(substTy, SGM.M);

  // Use the same generic environment as the native entry point.
  F.setGenericEnvironment(nativeInfo.GenericEnv);

  auto loc = thunk.getAsRegularLocation();
  loc.markAutoGenerated();
  Scope scope(Cleanups, CleanupLocation::get(loc));

  // If we are bridging a Swift method with an Any return value, create a
  // stack allocation to hold the result, since Any is address-only.
  SmallVector<SILValue, 4> args;

  if (substConv.hasIndirectSILResults()) {
    args.push_back(
        emitTemporaryAllocation(loc, substConv.getSingleSILResultType()));
  }

  // If the '@objc' was inferred due to deprecated rules,
  // emit a Builtin.swift3ImplicitObjCEntrypoint().
  //
  // However, don't do so for 'dynamic' members, which must use Objective-C
  // dispatch and therefore create many false positives.
  if (thunk.hasDecl()) {
    auto decl = thunk.getDecl();

    // For an accessor, look at the storage declaration's attributes.
    if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
      decl = accessor->getStorage();
    }

    if (auto attr = decl->getAttrs().getAttribute<ObjCAttr>()) {
      // If @objc was inferred based on the Swift 3 @objc inference rules, but
      // we aren't compiling in Swift 3 compatibility mode, emit a call to
      // Builtin.swift3ImplicitObjCEntrypoint() to enable runtime logging of
      // the uses of such entrypoints.
      if (attr->isSwift3Inferred() &&
          !decl->getAttrs().hasAttribute<DynamicAttr>() &&
          !getASTContext().LangOpts.isSwiftVersion3()) {
        
        // Get the starting source location of the declaration so we can say
        // exactly where to stick '@objc'.
        SourceLoc objcInsertionLoc =
          decl->getAttributeInsertionLoc(/*modifier*/ false);

        auto objcInsertionLocArgs
          = emitSourceLocationArgs(objcInsertionLoc, loc);
        
        B.createBuiltin(loc,
          getASTContext().getIdentifier(""swift3ImplicitObjCEntrypoint""),
          getModule().Types.getEmptyTupleType(), { }, {
            objcInsertionLocArgs.filenameStartPointer.forward(*this),
            objcInsertionLocArgs.filenameLength.forward(*this),
            objcInsertionLocArgs.line.forward(*this),
            objcInsertionLocArgs.column.forward(*this)
          });
      }
    }
  }

  // Now, enter a cleanup used for bridging the arguments. Note that if we
  // have an indirect result, it must be outside of this scope, otherwise
  // we will deallocate it too early.
  Scope argScope(Cleanups, CleanupLocation::get(loc));

  // Bridge the arguments.
  Optional<ForeignErrorConvention> foreignError;
  SILValue foreignErrorSlot;
  CanType nativeFormalResultType, bridgedFormalResultType;
  auto objcFnTy = emitObjCThunkArguments(*this, loc, thunk, args,
                                         foreignErrorSlot, foreignError,
                                         nativeFormalResultType,
                                         bridgedFormalResultType);
  SILFunctionConventions objcConv(CanSILFunctionType(objcFnTy), SGM.M);
  SILFunctionConventions nativeConv(CanSILFunctionType(nativeInfo.SILFnType),
                                    SGM.M);
  auto swiftResultTy = F.mapTypeIntoContext(nativeConv.getSILResultType());
  auto objcResultTy = objcConv.getSILResultType();

  // Call the native entry point.
  SILValue nativeFn = emitGlobalFunctionRef(loc, native, nativeInfo);

  SILValue result;
  assert(foreignError.hasValue() == substTy->hasErrorResult());
  if (!substTy->hasErrorResult()) {
    // Create the apply.
    result = B.createApply(loc, nativeFn, substSILTy,
                           swiftResultTy, subs, args);

    if (substConv.hasIndirectSILResults()) {
      assert(substTy->getNumResults() == 1);
      result = args[0];
    }

    // Leave the argument cleanup scope immediately.  This isn't really
    // necessary; it just limits lifetimes a little bit more.
    argScope.pop();

    // Now bridge the return value.
    result = emitBridgeReturnValue(*this, loc, result, nativeFormalResultType,
                                   bridgedFormalResultType, objcResultTy);
  } else {
    SILBasicBlock *contBB = createBasicBlock();
    SILBasicBlock *errorBB = createBasicBlock();
    SILBasicBlock *normalBB = createBasicBlock();
    B.createTryApply(loc, nativeFn, substSILTy, subs, args,
                     normalBB, errorBB);

    // Emit the non-error destination.
    {
      B.emitBlock(normalBB);
      SILValue nativeResult =
          normalBB->createPHIArgument(swiftResultTy, ValueOwnershipKind::Owned);

      if (substConv.hasIndirectSILResults()) {
        assert(substTy->getNumResults() == 1);
        nativeResult = args[0];
      }

      // In this branch, the eventual return value is mostly created
      // by bridging the native return value, but we may need to
      // adjust it slightly.
      SILValue bridgedResult =
        emitBridgeReturnValueForForeignError(loc, nativeResult,
                                             nativeFormalResultType,
                                             bridgedFormalResultType,
                                             objcResultTy,
                                             foreignErrorSlot, *foreignError);
      B.createBranch(loc, contBB, bridgedResult);
    }

    // Emit the error destination.
    {
      B.emitBlock(errorBB);
      SILValue nativeError = errorBB->createPHIArgument(
          substConv.getSILErrorType(), ValueOwnershipKind::Owned);

      // In this branch, the eventual return value is mostly invented.
      // Store the native error in the appropriate location and return.
      SILValue bridgedResult =
        emitBridgeErrorForForeignError(loc, nativeError, objcResultTy,
                                       foreignErrorSlot, *foreignError);
      B.createBranch(loc, contBB, bridgedResult);
    }

    // Emit the join block.
    B.emitBlock(contBB);
    result = contBB->createPHIArgument(objcResultTy, ValueOwnershipKind::Owned);

    // Leave the scope now.
    argScope.pop();
  }

  scope.pop();
  B.createReturn(loc, result);
}

static SILValue
getThunkedForeignFunctionRef(SILGenFunction &SGF,
                             SILLocation loc,
                             SILDeclRef foreign,
                             ArrayRef<ManagedValue> args,
                             SubstitutionList subs,
                             const SILConstantInfo &foreignCI) {
  assert(!foreign.isCurried
         && ""should not thunk calling convention when curried"");
  assert(foreign.isForeign);

  // Produce an objc_method when thunking ObjC methods.
  if (foreignCI.SILFnType->getRepresentation()
        == SILFunctionTypeRepresentation::ObjCMethod) {
    SILValue thisArg = args.back().getValue();

    return SGF.B.createObjCMethod(loc, thisArg, foreign,
                                  foreignCI.getSILType());
  }

  // Otherwise, emit a function_ref.
  return SGF.emitGlobalFunctionRef(loc, foreign);
}

/// Generate code to emit a thunk with native conventions that calls a
/// function with foreign conventions.
void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
  assert(!thunk.isForeign && ""foreign-to-native thunks only"");

  // Wrap the function in its original form.

  auto fd = cast<AbstractFunctionDecl>(thunk.getDecl());
  auto nativeCI = getConstantInfo(thunk);
  auto nativeFnTy = F.getLoweredFunctionType();
  assert(nativeFnTy == nativeCI.SILFnType);

  // Use the same generic environment as the native entry point.
  F.setGenericEnvironment(nativeCI.GenericEnv);
  
  SILDeclRef foreignDeclRef = thunk.asForeign(true);
  SILConstantInfo foreignCI = getConstantInfo(foreignDeclRef);
  auto foreignFnTy = foreignCI.SILFnType;

  // Find the foreign error convention and 'self' parameter index.
  Optional<ForeignErrorConvention> foreignError;
  if (nativeFnTy->hasErrorResult()) {
    foreignError = fd->getForeignErrorConvention();
    assert(foreignError && ""couldn't find foreign error convention!"");
  }
  ImportAsMemberStatus memberStatus = fd->getImportAsMemberStatus();

  // Forward the arguments.
  auto forwardedParameters = fd->getParameterLists();

  // For allocating constructors, 'self' is a metatype, not the 'self' value
  // formally present in the constructor body.
  Type allocatorSelfType;
  if (thunk.kind == SILDeclRef::Kind::Allocator) {
    allocatorSelfType = forwardedParameters[0]
      ->getInterfaceType(getASTContext())
      ->getWithoutSpecifierType();
    if (F.getGenericEnvironment())
      allocatorSelfType = F.getGenericEnvironment()
        ->mapTypeIntoContext(allocatorSelfType);
    forwardedParameters = forwardedParameters.slice(1);
  }

  SmallVector<SILValue, 8> params;
  
  // Introduce indirect returns if necessary.
  // TODO: Handle exploded results? We don't currently need to since the only
  // bridged indirect type is Any.
  SILValue indirectResult;
  SILFunctionConventions nativeConv(nativeFnTy, SGM.M);
  if (nativeConv.hasIndirectSILResults()) {
    assert(nativeConv.getNumIndirectSILResults() == 1
           && ""bridged exploded result?!"");
    indirectResult =
        F.begin()->createFunctionArgument(nativeConv.getSingleSILResultType());
  }
  
  for (auto *paramList : reversed(forwardedParameters))
    bindParametersForForwarding(paramList, params);

  if (allocatorSelfType) {
    auto selfMetatype =
      CanMetatypeType::get(allocatorSelfType->getCanonicalType());
    auto selfArg = F.begin()->createFunctionArgument(
        getLoweredLoadableType(selfMetatype), fd->getImplicitSelfDecl());
    params.push_back(selfArg);
  }

  // Set up the throw destination if necessary.
  CleanupLocation cleanupLoc(fd);
  if (foreignError) {
    prepareRethrowEpilog(cleanupLoc);
  }

  SILValue result;
  {
    Scope scope(Cleanups, fd);

    // Bridge all the arguments.
    SmallVector<ManagedValue, 8> args;
    unsigned foreignArgIndex = 0;

    // A helper function to add a function error argument in the
    // appropriate position.
    auto maybeAddForeignErrorArg = [&] {
      if (foreignError &&
          foreignArgIndex == foreignError->getErrorParameterIndex()) {
        args.push_back(ManagedValue());
        foreignArgIndex++;
      }
    };

    {
      auto foreignFormalParams =
        expandTupleTypes(foreignCI.LoweredType.getParams());
      auto nativeFormalParams =
        expandTupleTypes(nativeCI.LoweredType.getParams());

      for (unsigned nativeParamIndex : indices(params)) {
        // Bring the parameter to +1.
        auto paramValue = params[nativeParamIndex];
        auto thunkParam = nativeFnTy->getParameters()[nativeParamIndex];
        // TODO: Could avoid a retain if the bridged parameter is also +0 and
        // doesn't require a bridging conversion.
        ManagedValue param;
        switch (thunkParam.getConvention()) {
        case ParameterConvention::Direct_Owned:
          param = emitManagedRValueWithCleanup(paramValue);
          break;
        case ParameterConvention::Direct_Guaranteed:
        case ParameterConvention::Direct_Unowned:
          param = emitManagedRetain(fd, paramValue);
          break;
        case ParameterConvention::Indirect_Inout:
        case ParameterConvention::Indirect_InoutAliasable:
          param = ManagedValue::forLValue(paramValue);
          break;
        case ParameterConvention::Indirect_In:
          param = emitManagedRValueWithCleanup(paramValue);
          break;
        case ParameterConvention::Indirect_In_Guaranteed: {
          auto tmp = emitTemporaryAllocation(fd, paramValue->getType());
          B.createCopyAddr(fd, paramValue, tmp, IsNotTake, IsInitialization);
          param = emitManagedRValueWithCleanup(tmp);
          break;
        }
        case ParameterConvention::Indirect_In_Constant:
          llvm_unreachable(""unsupported convention"");
        }

        maybeAddForeignErrorArg();

        bool isSelf = nativeParamIndex == params.size() - 1;

        if (memberStatus.isInstance()) {
          // Leave space for `self` to be filled in later.
          if (foreignArgIndex == memberStatus.getSelfIndex()) {
            args.push_back({});
            foreignArgIndex++;
          }
          
          // Use the `self` space we skipped earlier if it's time.
          if (isSelf) {
            foreignArgIndex = memberStatus.getSelfIndex();
          }
        } else if (memberStatus.isStatic() && isSelf) {
          // Lose a static `self` parameter.
          break;
        }

        CanType nativeFormalType =
          F.mapTypeIntoContext(nativeFormalParams[nativeParamIndex])
            ->getCanonicalType();
        CanType foreignFormalType =
          F.mapTypeIntoContext(foreignFormalParams[nativeParamIndex])
            ->getCanonicalType();

        auto foreignParam = foreignFnTy->getParameters()[foreignArgIndex++];
        SILType foreignLoweredTy =
          F.mapTypeIntoContext(foreignParam.getSILStorageType());

        auto bridged = emitNativeToBridgedValue(fd, param, nativeFormalType,
                                                foreignFormalType,
                                                foreignLoweredTy);
        // Handle C pointer arguments imported as indirect `self` arguments.
        if (foreignParam.getConvention() == ParameterConvention::Indirect_In) {
          auto temp = emitTemporaryAllocation(fd, bridged.getType());
          bridged.forwardInto(*this, fd, temp);
          bridged = emitManagedBufferWithCleanup(temp);
        }
        
        if (memberStatus.isInstance() && isSelf) {
          // Fill in the `self` space.
          args[memberStatus.getSelfIndex()] = bridged;
        } else {
          args.push_back(bridged);
        }
      }
    }

    maybeAddForeignErrorArg();
    
    // Call the original.
    auto subs = getForwardingSubstitutions();
    auto fn = getThunkedForeignFunctionRef(*this, fd, foreignDeclRef, args, subs,
                                           foreignCI);

    auto fnType = fn->getType().castTo<SILFunctionType>();
    fnType = fnType->substGenericArgs(SGM.M, subs);

    CanType nativeFormalResultType =
        fd->mapTypeIntoContext(nativeCI.LoweredType.getResult())
            ->getCanonicalType();
    CanType bridgedFormalResultType =
        fd->mapTypeIntoContext(foreignCI.LoweredType.getResult())
            ->getCanonicalType();
    CalleeTypeInfo calleeTypeInfo(
        fnType, AbstractionPattern(nativeFnTy->getGenericSignature(),
                                   bridgedFormalResultType),
        nativeFormalResultType, foreignError, ImportAsMemberStatus());

    auto init = indirectResult
                ? useBufferAsTemporary(indirectResult,
                                    getTypeLowering(indirectResult->getType()))
                : nullptr;

    SGFContext context(init.get());
    ResultPlanPtr resultPlan = ResultPlanBuilder::computeResultPlan(
        *this, calleeTypeInfo, fd, context);
    ArgumentScope argScope(*this, fd);
    ManagedValue resultMV =
        emitApply(std::move(resultPlan), std::move(argScope), fd,
                  ManagedValue::forUnmanaged(fn), subs, args, calleeTypeInfo,
                  ApplyOptions::None, context)
            .getAsSingleValue(*this, fd);

    if (indirectResult) {
      if (!resultMV.isInContext()) {
        init->copyOrInitValueInto(*this, fd, resultMV, /*isInit*/ true);
        init->finishInitialization(*this);
      }
      init->getManagedAddress().forward(*this);
      result = emitEmptyTuple(fd);
    } else {
      result = resultMV.forward(*this);
    }
  }
  B.createReturn(ImplicitReturnLocation::getImplicitReturnLoc(fd), result);
  // Emit the throw destination.
  emitRethrowEpilog(fd);
}
",16242,True,3332.3085619139106,median
"[[azure-storage-blob-component]]
= Azure Storage Blob Service Component
:docTitle: Azure Storage Blob Service
:artifactId: camel-azure-storage-blob
:description: Store and retrieve blobs from Azure Storage Blob Service using SDK v12.
:since: 3.3
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/azure-storage-blob.adoc[opts=optional]
//Manually maintained attributes
:group: Azure

*Since Camel {since}*

*{component-header}*

The Azure Storage Blob component is used for storing and retrieving blobs from https://azure.microsoft.com/services/storage/blobs/[Azure Storage Blob] Service using *Azure APIs v12*. However in case of versions above v12,
we will see if this component can adopt these changes depending on how much breaking changes can result.

Prerequisites

You must have a valid Windows Azure Storage account. More information is available at
https://docs.microsoft.com/azure/[Azure Documentation Portal].

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-azure-storage-blob</artifactId>
    <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------


== URI Format

[source,text]
------------------------------
azure-storage-blob://accountName[/containerName][?options]
------------------------------

In case of consumer, accountName, containerName are required. In case of producer, it depends on the operation that being
requested, for example if operation is on a container level, e.b: createContainer, accountName and containerName are only required, but in case
of operation being requested in blob level, e.g: getBlob, accountName, containerName and blobName are required.

The blob will be created if it does not already exist.
You can append query options to the URI in the following format, ?options=value&option2=value&...

For example in order to download a blob content from the block blob `hello.txt`
located on the `container1` in the `camelazure` storage account, use the following snippet:

[source,java]
--------------------------------------------------------------------------------
from(""azure-storage-blob://camelazure/container1?blobName=hello.txt&accessKey=yourAccessKey"").
to(""file://blobdirectory"");
--------------------------------------------------------------------------------



== URI Options


// component options: START
The Azure Storage Blob Service component supports 30 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *blobName* (common) | The blob name, to consume specific blob from a container. However on producer, is only required for the operations on the blob level |  | String
| *blobOffset* (common) | Set the blob offset for the upload or download operations, default is 0 | 0 | long
| *blobType* (common) | The blob type in order to initiate the appropriate settings for each blob type. There are 3 enums and the value can be one of: blockblob, appendblob, pageblob | blockblob | BlobType
| *closeStreamAfterRead* (common) | Close the stream after read or keep it open, default is true | true | boolean
| *configuration* (common) | The component configurations |  | BlobConfiguration
| *credentials* (common) | StorageSharedKeyCredential can be injected to create the azure client, this holds the important authentication information |  | StorageSharedKeyCredential
| *dataCount* (common) | How many bytes to include in the range. Must be greater than or equal to 0 if specified. |  | Long
| *fileDir* (common) | The file directory where the downloaded blobs will be saved to, this can be used in both, producer and consumer |  | String
| *maxResultsPerPage* (common) | Specifies the maximum number of blobs to return, including all BlobPrefix elements. If the request does not specify maxResultsPerPage or specifies a value greater than 5,000, the server will return up to 5,000 items. |  | Integer
| *maxRetryRequests* (common) | Specifies the maximum number of additional HTTP Get requests that will be made while reading the data from a response body. | 0 | int
| *prefix* (common) | Filters the results to return only blobs whose names begin with the specified prefix. May be null to return all blobs. |  | String
| *regex* (common) | Filters the results to return only blobs whose names match the specified regular expression. May be null to return all if both prefix and regex are set, regex takes the priority and prefix is ignored. |  | String
| *serviceClient* (common) | *Autowired* Client to a storage account. This client does not hold any state about a particular storage account but is instead a convenient way of sending off appropriate requests to the resource on the service. It may also be used to construct URLs to blobs and containers. This client contains operations on a service account. Operations on a container are available on BlobContainerClient through BlobServiceClient#getBlobContainerClient(String), and operations on a blob are available on BlobClient through BlobContainerClient#getBlobClient(String). |  | BlobServiceClient
| *timeout* (common) | An optional timeout value beyond which a RuntimeException will be raised. |  | Duration
| *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
| *blobSequenceNumber* (producer) | A user-controlled value that you can use to track requests. The value of the sequence number must be between 0 and 263 - 1.The default value is 0. | 0 | Long
| *blockListType* (producer) | Specifies which type of blocks to return. There are 3 enums and the value can be one of: committed, uncommitted, all | COMMITTED | BlockListType
| *changeFeedContext* (producer) | When using getChangeFeed producer operation, this gives additional context that is passed through the Http pipeline during the service call. |  | Context
| *changeFeedEndTime* (producer) | When using getChangeFeed producer operation, this filters the results to return events approximately before the end time. Note: A few events belonging to the next hour can also be returned. A few events belonging to this hour can be missing; to ensure all events from the hour are returned, round the end time up by an hour. |  | OffsetDateTime
| *changeFeedStartTime* (producer) | When using getChangeFeed producer operation, this filters the results to return events approximately after the start time. Note: A few events belonging to the previous hour can also be returned. A few events belonging to this hour can be missing; to ensure all events from the hour are returned, round the start time down by an hour. |  | OffsetDateTime
| *closeStreamAfterWrite* (producer) | Close the stream after write or keep it open, default is true | true | boolean
| *commitBlockListLater* (producer) | When is set to true, the staged blocks will not be committed directly. | true | boolean
| *createAppendBlob* (producer) | When is set to true, the append blocks will be created when committing append blocks. | true | boolean
| *createPageBlob* (producer) | When is set to true, the page blob will be created when uploading page blob. | true | boolean
| *downloadLinkExpiration* (producer) | Override the default expiration (millis) of URL download link. |  | Long
| *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
| *operation* (producer) | The blob operation that can be used with this component on the producer. There are 19 enums and the value can be one of: listBlobContainers, createBlobContainer, deleteBlobContainer, listBlobs, getBlob, deleteBlob, downloadBlobToFile, downloadLink, uploadBlockBlob, stageBlockBlobList, commitBlobBlockList, getBlobBlockList, createAppendBlob, commitAppendBlob, createPageBlob, uploadPageBlob, resizePageBlob, clearPageBlob, getPageBlobRanges | listBlobContainers | BlobOperationsDefinition
| *pageBlobSize* (producer) | Specifies the maximum size for the page blob, up to 8 TB. The page blob size must be aligned to a 512-byte boundary. | 512 | Long
| *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
| *accessKey* (security) | Access key for the associated azure account name to be used for authentication with azure blob services |  | String
|===
// component options: END

// endpoint options: START
The Azure Storage Blob Service endpoint is configured using URI syntax:

----
azure-storage-blob:accountName/containerName
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *accountName* | Azure account name to be used for authentication with azure blob services |  | String
| *containerName* | The blob container name |  | String
|===


=== Query Parameters (47 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *blobName* (common) | The blob name, to consume specific blob from a container. However on producer, is only required for the operations on the blob level |  | String
| *blobOffset* (common) | Set the blob offset for the upload or download operations, default is 0 | 0 | long
| *blobServiceClient* (common) | Client to a storage account. This client does not hold any state about a particular storage account but is instead a convenient way of sending off appropriate requests to the resource on the service. It may also be used to construct URLs to blobs and containers. This client contains operations on a service account. Operations on a container are available on BlobContainerClient through getBlobContainerClient(String), and operations on a blob are available on BlobClient through getBlobContainerClient(String).getBlobClient(String). |  | BlobServiceClient
| *blobType* (common) | The blob type in order to initiate the appropriate settings for each blob type. There are 3 enums and the value can be one of: blockblob, appendblob, pageblob | blockblob | BlobType
| *closeStreamAfterRead* (common) | Close the stream after read or keep it open, default is true | true | boolean
| *credentials* (common) | StorageSharedKeyCredential can be injected to create the azure client, this holds the important authentication information |  | StorageSharedKeyCredential
| *dataCount* (common) | How many bytes to include in the range. Must be greater than or equal to 0 if specified. |  | Long
| *fileDir* (common) | The file directory where the downloaded blobs will be saved to, this can be used in both, producer and consumer |  | String
| *maxResultsPerPage* (common) | Specifies the maximum number of blobs to return, including all BlobPrefix elements. If the request does not specify maxResultsPerPage or specifies a value greater than 5,000, the server will return up to 5,000 items. |  | Integer
| *maxRetryRequests* (common) | Specifies the maximum number of additional HTTP Get requests that will be made while reading the data from a response body. | 0 | int
| *prefix* (common) | Filters the results to return only blobs whose names begin with the specified prefix. May be null to return all blobs. |  | String
| *regex* (common) | Filters the results to return only blobs whose names match the specified regular expression. May be null to return all if both prefix and regex are set, regex takes the priority and prefix is ignored. |  | String
| *serviceClient* (common) | *Autowired* Client to a storage account. This client does not hold any state about a particular storage account but is instead a convenient way of sending off appropriate requests to the resource on the service. It may also be used to construct URLs to blobs and containers. This client contains operations on a service account. Operations on a container are available on BlobContainerClient through BlobServiceClient#getBlobContainerClient(String), and operations on a blob are available on BlobClient through BlobContainerClient#getBlobClient(String). |  | BlobServiceClient
| *timeout* (common) | An optional timeout value beyond which a RuntimeException will be raised. |  | Duration
| *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
| *sendEmptyMessageWhenIdle* (consumer) | If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead. | false | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *pollStrategy* (consumer) | A pluggable org.apache.camel.PollingConsumerPollingStrategy allowing you to provide your custom implementation to control error handling usually occurred during the poll operation before an Exchange have been created and being routed in Camel. |  | PollingConsumerPollStrategy
| *blobSequenceNumber* (producer) | A user-controlled value that you can use to track requests. The value of the sequence number must be between 0 and 263 - 1.The default value is 0. | 0 | Long
| *blockListType* (producer) | Specifies which type of blocks to return. There are 3 enums and the value can be one of: committed, uncommitted, all | COMMITTED | BlockListType
| *changeFeedContext* (producer) | When using getChangeFeed producer operation, this gives additional context that is passed through the Http pipeline during the service call. |  | Context
| *changeFeedEndTime* (producer) | When using getChangeFeed producer operation, this filters the results to return events approximately before the end time. Note: A few events belonging to the next hour can also be returned. A few events belonging to this hour can be missing; to ensure all events from the hour are returned, round the end time up by an hour. |  | OffsetDateTime
| *changeFeedStartTime* (producer) | When using getChangeFeed producer operation, this filters the results to return events approximately after the start time. Note: A few events belonging to the previous hour can also be returned. A few events belonging to this hour can be missing; to ensure all events from the hour are returned, round the start time down by an hour. |  | OffsetDateTime
| *closeStreamAfterWrite* (producer) | Close the stream after write or keep it open, default is true | true | boolean
| *commitBlockListLater* (producer) | When is set to true, the staged blocks will not be committed directly. | true | boolean
| *createAppendBlob* (producer) | When is set to true, the append blocks will be created when committing append blocks. | true | boolean
| *createPageBlob* (producer) | When is set to true, the page blob will be created when uploading page blob. | true | boolean
| *downloadLinkExpiration* (producer) | Override the default expiration (millis) of URL download link. |  | Long
| *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
| *operation* (producer) | The blob operation that can be used with this component on the producer. There are 19 enums and the value can be one of: listBlobContainers, createBlobContainer, deleteBlobContainer, listBlobs, getBlob, deleteBlob, downloadBlobToFile, downloadLink, uploadBlockBlob, stageBlockBlobList, commitBlobBlockList, getBlobBlockList, createAppendBlob, commitAppendBlob, createPageBlob, uploadPageBlob, resizePageBlob, clearPageBlob, getPageBlobRanges | listBlobContainers | BlobOperationsDefinition
| *pageBlobSize* (producer) | Specifies the maximum size for the page blob, up to 8 TB. The page blob size must be aligned to a 512-byte boundary. | 512 | Long
| *backoffErrorThreshold* (scheduler) | The number of subsequent error polls (failed due some error) that should happen before the backoffMultipler should kick-in. |  | int
| *backoffIdleThreshold* (scheduler) | The number of subsequent idle polls that should happen before the backoffMultipler should kick-in. |  | int
| *backoffMultiplier* (scheduler) | To let the scheduled polling consumer backoff if there has been a number of subsequent idles/errors in a row. The multiplier is then the number of polls that will be skipped before the next actual attempt is happening again. When this option is in use then backoffIdleThreshold and/or backoffErrorThreshold must also be configured. |  | int
| *delay* (scheduler) | Milliseconds before the next poll. | 500 | long
| *greedy* (scheduler) | If greedy is enabled, then the ScheduledPollConsumer will run immediately again, if the previous run polled 1 or more messages. | false | boolean
| *initialDelay* (scheduler) | Milliseconds before the first poll starts. | 1000 | long
| *repeatCount* (scheduler) | Specifies a maximum limit of number of fires. So if you set it to 1, the scheduler will only fire once. If you set it to 5, it will only fire five times. A value of zero or negative means fire forever. | 0 | long
| *runLoggingLevel* (scheduler) | The consumer logs a start/complete log line when it polls. This option allows you to configure the logging level for that. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | TRACE | LoggingLevel
| *scheduledExecutorService* (scheduler) | Allows for configuring a custom/shared thread pool to use for the consumer. By default each consumer has its own single threaded thread pool. |  | ScheduledExecutorService
| *scheduler* (scheduler) | To use a cron scheduler from either camel-spring or camel-quartz component. Use value spring or quartz for built in scheduler | none | Object
| *schedulerProperties* (scheduler) | To configure additional properties when using a custom scheduler or any of the Quartz, Spring based scheduler. |  | Map
| *startScheduler* (scheduler) | Whether the scheduler should be auto started. | true | boolean
| *timeUnit* (scheduler) | Time unit for initialDelay and delay options. There are 7 enums and the value can be one of: NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS | MILLISECONDS | TimeUnit
| *useFixedDelay* (scheduler) | Controls if fixed delay or fixed rate is used. See ScheduledExecutorService in JDK for details. | true | boolean
| *accessKey* (security) | Access key for the associated azure account name to be used for authentication with azure blob services |  | String
|===
// endpoint options: END

*Required information options:*

To use this component, you have 3 options in order to provide the required Azure authentication information:

- Provide `accountName` and `accessKey` for your Azure account, this is the simplest way to get started. The accessKey can
be generated through your Azure portal.
- Provide a https://azuresdkartifacts.blob.core.windows.net/azure-sdk-for-java/staging/apidocs/com/azure/storage/common/StorageSharedKeyCredential.html[StorageSharedKeyCredential] instance which can be
provided into `credentials` option.
- Provide a https://azuresdkdocs.blob.core.windows.net/$web/java/azure-storage-blob/12.0.0/com/azure/storage/blob/BlobServiceClient.html[BlobServiceClient] instance which can be
provided into `blobServiceClient`. Note: You don't need to create a specific client, e.g: BlockBlobClient, the BlobServiceClient represents the upper level which
can be used to retrieve lower level clients.


== Batch Consumer

This component implements the Batch Consumer.

This allows you for instance to know how many messages exists in this
batch and for instance let the Aggregator
aggregate this number of messages.


== Usage

=== Message headers evaluated by the component producer
[width=""100%"",cols=""10%,10%,10%,10%,60%"",options=""header"",]
|=======================================================================
|Header |Variable Name |Type |Operations |Description

|`CamelAzureStorageBlobTimeout` |`BlobConstants.TIMEOUT`|`Duration`|All|An optional timeout value beyond which a {@link RuntimeException} will be raised.
|`CamelAzureStorageBlobMetadata`|`BlobConstants.METADATA`|`Map<String,String>`|Operations related to container and blob| Metadata to associate with the container or blob.
|`CamelAzureStorageBlobPublicAccessType`|`BlobConstants.PUBLIC_ACCESS_TYPE`|`PublicAccessType`|`createContainer`|Specifies how the data in this container is available to the public. Pass `null` for no public access.
|`CamelAzureStorageBlobRequestCondition`|`BlobConstants.BLOB_REQUEST_CONDITION`|`BlobRequestConditions`|Operations related to container and blob|This contains values which will restrict the successful operation of a variety of requests to the conditions present. These conditions are entirely optional.
|`CamelAzureStorageBlobListDetails`|`BlobConstants.BLOB_LIST_DETAILS`|`BlobListDetails`|`listBlobs`|The details for listing specific blobs
|`CamelAzureStorageBlobPrefix`|`BlobConstants.PREFIX`|`String`|`listBlobs`,`getBlob`|Filters the results to return only blobs whose names begin with the specified prefix. May be null to return all blobs.
|`CamelAzureStorageBlobMaxResultsPerPage`|`BlobConstants.MAX_RESULTS_PER_PAGE`|`Integer`|`listBlobs`| Specifies the maximum number of blobs to return, including all BlobPrefix elements. If the request does not specify maxResultsPerPage or specifies a value greater than 5,000, the server will return up to 5,000 items.
|`CamelAzureStorageBlobListBlobOptions`|`BlobConstants.LIST_BLOB_OPTIONS`|`ListBlobsOptions`|`listBlobs`|Defines options available to configure the behavior of a call to listBlobsFlatSegment on a {@link BlobContainerClient} object.
|`CamelAzureStorageBlobHttpHeaders`|`BlobConstants.BLOB_HTTP_HEADERS`|`BlobHttpHeaders`|`uploadBlockBlob`, `commitBlobBlockList`, `createAppendBlob`, `createPageBlob`|  Additional parameters for a set of operations.
|`CamelAzureStorageBlobAccessTier`|`BlobConstants.ACCESS_TIER`|`AccessTier`|`uploadBlockBlob`, `commitBlobBlockList`| Defines values for AccessTier.
|`CamelAzureStorageBlobContentMD5`|`BlobConstants.CONTENT_MD5`|`byte[]`|Most operations related to upload blob|An MD5 hash of the block content. This hash is used to verify the integrity of the block during transport. When this header is specified, the storage service compares the hash of the content that has arrived with this header value. Note that this MD5 hash is not stored with the blob. If the two hashes do not match, the operation will fail.
|`CamelAzureStorageBlobPageBlobRange`|`BlobConstants.PAGE_BLOB_RANGE`|`PageRange`|Operations related to page blob| A {@link PageRange} object. Given that pages must be aligned with 512-byte boundaries, the start offset must be a modulus of 512 and the end offset must be a modulus of 512 - 1. Examples of valid byte ranges are 0-511, 512-1023, etc.
|`CamelAzureStorageBlobCommitBlobBlockListLater`|`BlobConstants.COMMIT_BLOCK_LIST_LATER`|`boolean`|`stageBlockBlobList`| When is set to `true`, the staged blocks will not be committed directly.
|`CamelAzureStorageBlobCreateAppendBlob`|`BlobConstants.CREATE_APPEND_BLOB`|`boolean`|`commitAppendBlob`| When is set to `true`, the append blocks will be created when committing append blocks.
|`CamelAzureStorageBlobCreatePageBlob`|`BlobConstants.CREATE_PAGE_BLOB`|`boolean`|`uploadPageBlob`| When is set to `true`, the page blob will be created when uploading page blob.
|`CamelAzureStorageBlobBlockListType`|`BlobConstants.BLOCK_LIST_TYPE`|`BlockListType`|`getBlobBlockList`| Specifies which type of blocks to return.
|`CamelAzureStorageBlobPageBlobSize`|`BlobConstants.PAGE_BLOB_SIZE`|`Long`|`createPageBlob`, `resizePageBlob`| Specifies the maximum size for the page blob, up to 8 TB. The page blob size must be aligned to a 512-byte boundary.
|`CamelAzureStorageBlobSequenceNumber`|`BlobConstants.BLOB_SEQUENCE_NUMBER`|`Long`|`createPageBlob`|A user-controlled value that you can use to track requests. The value of the sequence number must be between 0 and 2^63 - 1.The default value is 0.
|`CamelAzureStorageBlobDeleteSnapshotsOptionType`|`BlobConstants.DELETE_SNAPSHOT_OPTION_TYPE`|`DeleteSnapshotsOptionType`|`deleteBlob`| Specifies the behavior for deleting the snapshots on this blob. {@code Include} will delete the base blob and all snapshots. {@code Only} will delete only the snapshots. If a snapshot is being deleted, you must pass null.
|`CamelAzureStorageBlobListBlobContainersOptions`|`BlobConstants.LIST_BLOB_CONTAINERS_OPTIONS`|`ListBlobContainersOptions`|`listBlobContainers`| A {@link ListBlobContainersOptions} which specifies what data should be returned by the service.
|`CamelAzureStorageBlobParallelTransferOptions`|`BlobConstants.PARALLEL_TRANSFER_OPTIONS`|`ParallelTransferOptions`|`downloadBlobToFile`| {@link ParallelTransferOptions} to use to download to file. Number of parallel transfers parameter is ignored.
|`CamelAzureStorageBlobFileDir`|`BlobConstants.FILE_DIR`|`String`|`downloadBlobToFile`|The file directory where the downloaded blobs will be saved to.
|`CamelAzureStorageBlobDownloadLinkExpiration`|`BlobConstants.DOWNLOAD_LINK_EXPIRATION`|`Long`|`downloadLink`| Override the default expiration (millis) of URL download link.
|`CamelAzureStorageBlobBlobName`|`BlobConstants.BLOB_NAME`|`String`|Operations related to blob| Override/set the blob name on the exchange headers.
|`CamelAzureStorageBlobContainerName`|`BlobConstants.BLOB_CONTAINER_NAME`|`String`|Operations related to container and blob|Override/set the container name on the exchange headers.
|`CamelAzureStorageBlobOperation`|`BlobConstants.BLOB_OPERATION`|`BlobOperationsDefinition`|All|Specify the producer operation to execute, please see the doc on this page related to producer operation.
|`CamelAzureStorageBlobRegex`|`BlobConstants.REGEX`|`String`|`listBlobs`,`getBlob`|Filters the results to return only blobs whose names match the specified regular expression. May be null to return all. If both prefix and regex are set, regex takes the priority and prefix is ignored.
|`CamelAzureStorageBlobChangeFeedStartTime`|`BlobConstants.CHANGE_FEED_START_TIME`|`OffsetDateTime`|`getChangeFeed`| It filters the results to return events approximately after the start time. Note: A few events belonging to the previous hour can also be returned. A few events belonging to this hour can be missing; to ensure all events from the hour are returned, round the start time down by an hour.
|`CamelAzureStorageBlobChangeFeedEndTime`|`BlobConstants.CHANGE_FEED_END_TIME`|`OffsetDateTime`|`getChangeFeed`| It filters  the results to return events approximately before the end time. Note: A few events belonging to the next hour can also be returned. A few events belonging to this hour can be missing; to ensure all events from the hour are returned, round the end time up by an hour.
|`CamelAzureStorageBlobChangeFeedContext`|`BlobConstants.CHANGE_FEED_CONTEXT`|`Context`|`getChangeFeed`| This gives additional context that is passed through the Http pipeline during the service call.
|=======================================================================

=== Message headers set by either component producer or consumer
[width=""100%"",cols=""10%,10%,10%,70%"",options=""header"",]
|=======================================================================
|Header |Variable Name |Type |Description

|`CamelAzureStorageBlobAccessTier`|`BlobConstants.ACCESS_TIER`|`AccessTier`| Access tier of the blob.
|`CamelAzureStorageBlobAccessTierChangeTime`|`BlobConstants.ACCESS_TIER_CHANGE_TIME`|`OffsetDateTime`| Datetime when the access tier of the blob last changed.
|`CamelAzureStorageBlobArchiveStatus`|`BlobConstants.ARCHIVE_STATUS`|`ArchiveStatus`|Archive status of the blob.
|`CamelAzureStorageBlobCreationTime`|`BlobConstants.CREATION_TIME`|`OffsetDateTime`|Creation time of the blob.
|`CamelAzureStorageBlobSequenceNumber`|`BlobConstants.BLOB_SEQUENCE_NUMBER`|`Long`|The current sequence number for a page blob.
|`CamelAzureStorageBlobBlobSize`|`BlobConstants.BLOB_SIZE`|`long`|The size of the blob.
|`CamelAzureStorageBlobBlobType`|`BlobConstants.BLOB_TYPE`|`BlobType`|The type of the blob.
|`CamelAzureStorageBlobCacheControl`|`BlobConstants.CACHE_CONTROL`|`String`|Cache control specified for the blob.
|`CamelAzureStorageBlobCommittedBlockCount`|`BlobConstants.COMMITTED_BLOCK_COUNT`|`Integer`|  Number of blocks committed to an append blob
|`CamelAzureStorageBlobContentDisposition`|`BlobConstants.CONTENT_DISPOSITION`|`String`|Content disposition specified for the blob.
|`CamelAzureStorageBlobContentEncoding`|`BlobConstants.CONTENT_ENCODING`|`String`|Content encoding specified for the blob.
|`CamelAzureStorageBlobContentLanguage`|`BlobConstants.CONTENT_LANGUAGE`|`String`|Content language specified for the blob.
|`CamelAzureStorageBlobContentMd5`|`BlobConstants.CONTENT_MD5`|`byte[]`|Content MD5 specified for the blob.
|`CamelAzureStorageBlobContentType`|`BlobConstants.CONTENT_TYPE`|`String`|Content type specified for the blob.
|`CamelAzureStorageBlobCopyCompletionTime`|`BlobConstants.COPY_COMPILATION_TIME`|`OffsetDateTime`|Datetime when the last copy operation on the blob completed.
|`CamelAzureStorageBlobCopyDestinationSnapshot`|`BlobConstants.COPY_DESTINATION_SNAPSHOT`|`String`|Snapshot identifier of the last incremental copy snapshot for the blob.
|`CamelAzureStorageBlobCopyId`|`BlobConstants.COPY_ID`|`String`|Identifier of the last copy operation performed on the blob.
|`CamelAzureStorageBlobCopyProgress`|`BlobConstants.COPY_PROGRESS`|`String`|Progress of the last copy operation performed on the blob.
|`CamelAzureStorageBlobCopySource`|`BlobConstants.COPY_SOURCE`|`String`|Source of the last copy operation performed on the blob.
|`CamelAzureStorageBlobCopyStatus`|`BlobConstants.COPY_STATUS`|`CopyStatusType`|Status of the last copy operation performed on the blob.
|`CamelAzureStorageBlobCopyStatusDescription` | `BlobConstants.COPY_STATUS_DESCRIPTION`|`String`|Description of the last copy operation on the blob.
|`CamelAzureStorageBlobETag`|`BlobConstants.E_TAG`|`String`| The E Tag of the blob
|`CamelAzureStorageBlobIsAccessTierInferred`|`BlobConstants.IS_ACCESS_TIER_INFRRRED`|`boolean`| Flag indicating if the access tier of the blob was inferred from properties of the blob.
|`CamelAzureStorageBlobIsIncrementalCopy`|`BlobConstants.IS_INCREMENTAL_COPY`|`boolean`|Flag indicating if the blob was incrementally copied.
|`CamelAzureStorageBlobIsServerEncrypted`|`BlobConstants.IS_SERVER_ENCRYPTED`|`boolean`|Flag indicating if the blob's content is encrypted on the server.
|`CamelAzureStorageBlobLastModified`|`BlobConstants.LAST_MODIFIED`|`OffsetDateTime`|Datetime when the blob was last modified.
|`CamelAzureStorageBlobLeaseDuration`|`BlobConstants.LEASE_DURATION`|`LeaseDurationType`|Type of lease on the blob.
|`CamelAzureStorageBlobLeaseState`|`BlobConstants.LEASE_STATE`|`LeaseStateType`|State of the lease on the blob.
|`CamelAzureStorageBlobLeaseStatus`|`BlobConstants.LEASE_STATUS`|`LeaseStatusType`|Status of the lease on the blob.
|`CamelAzureStorageBlobMetadata`|`BlobConstants.METADATA`|`Map<String, String>`| Additional metadata associated with the blob.
|`CamelAzureStorageBlobAppendOffset`|`BlobConstants.APPEND_OFFSET`|`String`| The offset at which the block was committed to the block blob.
|`CamelAzureStorageBlobFileName`|`BlobConstants.FILE_NAME`|`String`|The downloaded filename from the operation `downloadBlobToFile`.
|`CamelAzureStorageBlobDownloadLink`|`BlobConstants.DOWNLOAD_LINK`|`String`|The download link generated by `downloadLink` operation.
|`CamelAzureStorageBlobRawHttpHeaders`|`BlobConstants.RAW_HTTP_HEADERS`|`HttpHeaders`|Returns non-parsed httpHeaders that can be used by the user.
|=======================================================================

=== Advanced Azure Storage Blob configuration
If your Camel Application is running behind a firewall or if you need to
have more control over the `BlobServiceClient` instance configuration, you can
create your own instance:
[source,java]
-----------------------------------------------------------------------
StorageSharedKeyCredential credential = new StorageSharedKeyCredential(""yourAccountName"", ""yourAccessKey"");
String uri = String.format(""https://%s.blob.core.windows.net"", ""yourAccountName"");

BlobServiceClient client = new BlobServiceClientBuilder()
                          .endpoint(uri)
                          .credential(credential)
                          .buildClient();
// This is camel context
context.getRegistry().bind(""client"", client);
-----------------------------------------------------------------------

Then refer to this instance in your Camel `azure-storage-blob` component configuration:

[source,java]
-----------------------------------------------------------------------
from(""azure-storage-blob://cameldev/container1?blobName=myblob&serviceClient=#client"")
.to(""mock:result"");
-----------------------------------------------------------------------

=== Automatic detection of BlobServiceClient client in registry

The component is capable of detecting the presence of an BlobServiceClient bean into the registry.
If it's the only instance of that type it will be used as client and you won't have to define it as uri parameter, like the example above.
This may be really useful for smarter configuration of the endpoint.

=== Azure Storage Blob Producer operations

Camel Azure Storage Blob component provides wide range of operations on the producer side:

*Operations on the service level*

For these operations, `accountName` is *required*.
[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Operation |Description
|`listBlobContainers`  |Get the content of the blob. You can restrict the output of this operation to a blob range.
|`getChangeFeed` | Returns transaction logs of all the changes that occur to the blobs and the blob metadata in your storage account. The change feed provides ordered, guaranteed, durable, immutable, read-only log of these changes.
|===

*Operations on the container level*

For these operations, `accountName` and `containerName` are *required*.
[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Operation |Description
|`createBlobContainer` | Creates a new container within a storage account. If a container with the same name already exists, the producer will ignore it.
|`deleteBlobContainer` | Deletes the specified container in the storage account. If the container doesn't exist the operation fails.
|`listBlobs`| Returns a list of blobs in this container, with folder structures flattened.
|===

*Operations on the blob level*

For these operations, `accountName`, `containerName` and `blobName` are *required*.
[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|===
|Operation |Blob Type|Description
|`getBlob`  |Common|Get the content of the blob. You can restrict the output of this operation to a blob range.
|`deleteBlob`  |Common|Delete a blob.
|`downloadBlobToFile` |Common|Downloads the entire blob into a file specified by the path.The file will be created and must not exist, if the file already exists a {@link FileAlreadyExistsException} will be thrown.
|`downloadLink`  |Common| Generates the download link for the specified blob using shared access signatures (SAS). This by default only limit to 1hour of allowed access. However, you can override the default expiration duration through the headers.
|`uploadBlockBlob` |BlockBlob|Creates a new block blob, or updates the content of an existing block blob. Updating an existing block blob overwrites any existing metadata on the blob. Partial updates are not supported with PutBlob; the content of the existing blob is overwritten with the new content.
|`stageBlockBlobList`|`BlockBlob`|Uploads the specified block to the block blob's ""staging area"" to be later committed by a call to commitBlobBlockList. However in case header `CamelAzureStorageBlobCommitBlobBlockListLater` or config `commitBlockListLater` is set to false, this will commit the blocks immediately after staging the blocks.
|`commitBlobBlockList`|`BlockBlob`|Writes a blob by specifying the list of block IDs that are to make up the blob. In order to be written as part
                                    of a blob, a block must have been successfully written to the server in a prior `stageBlockBlobList` operation. You can
                                    call `commitBlobBlockList` to update a blob by uploading only those blocks that have changed, then committing the new
                                    and existing blocks together. Any blocks not specified in the block list and permanently deleted.
|`getBlobBlockList`  |`BlockBlob`|Returns the list of blocks that have been uploaded as part of a block blob using the specified block list filter.
|`createAppendBlob` |`AppendBlob`|Creates a 0-length append blob. Call commitAppendBlo`b operation to append data to an append blob.
|`commitAppendBlob` |`AppendBlob`|Commits a new block of data to the end of the existing append blob. In case of header `CamelAzureStorageBlobCreateAppendBlob` or config `createAppendBlob` is set to true, it will attempt to create the appendBlob through internal call to `createAppendBlob` operation first before committing.
|`createPageBlob`|`PageBlob`|Creates a page blob of the specified length. Call `uploadPageBlob` operation to upload data data to a page blob.
|`uploadPageBlob`|`PageBlob`|Writes one or more pages to the page blob. The write size must be a multiple of 512. In case of header `CamelAzureStorageBlobCreatePageBlob` or config `createPageBlob` is set to true, it will attempt to create the appendBlob through internal call to `createPageBlob` operation first before uploading.
|`resizePageBlob`|`PageBlob`| Resizes the page blob to the specified size (which must be a multiple of 512).
|`clearPageBlob`|`PageBlob`| Frees the specified pages from the page blob. The size of the range must be a multiple of 512.
|`getPageBlobRanges`|`PageBlob`|Returns the list of valid page ranges for a page blob or snapshot of a page blob.
|===

Refer to the example section in this page to learn how to use these operations into your camel application.

=== Consumer Examples
To consume a blob into a file using file component, this can be done like this:
[source,java]
--------------------------------------------------------------------------------
from(""azure-storage-blob://camelazure/container1?blobName=hello.txt&accountName=yourAccountName&accessKey=yourAccessKey"").
to(""file://blobdirectory"");
--------------------------------------------------------------------------------

However, you can also write to file directly without using the file component, you will need to specify `fileDir` folder path in order to save your blob in your machine.
[source,java]
--------------------------------------------------------------------------------
from(""azure-storage-blob://camelazure/container1?blobName=hello.txt&accountName=yourAccountName&accessKey=yourAccessKey&fileDir=/var/to/awesome/dir"").
to(""mock:results"");
--------------------------------------------------------------------------------

Also, the component supports batch consumer, hence you can consume multiple blobs with only specifying the container name, the consumer will
return multiple exchanges depending on the number of the blobs in the container. Example:
[source,java]
--------------------------------------------------------------------------------
from(""azure-storage-blob://camelazure/container1?accountName=yourAccountName&accessKey=yourAccessKey&fileDir=/var/to/awesome/dir"").
to(""mock:results"");
--------------------------------------------------------------------------------



=== Producer Operations Examples
- `listBlobContainers`:

[source,java]
--------------------------------------------------------------------------------
from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.LIST_BLOB_CONTAINERS_OPTIONS, new ListBlobContainersOptions().setMaxResultsPerPage(10));
  })
  .to(""azure-storage-blob://camelazure?operation=listBlobContainers&client&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `createBlobContainer`:

[source,java]
--------------------------------------------------------------------------------
from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_CONTAINER_NAME, ""newContainerName"");
  })
  .to(""azure-storage-blob://camelazure/container1?operation=createBlobContainer&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `deleteBlobContainer`:

[source,java]
--------------------------------------------------------------------------------
from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_CONTAINER_NAME, ""overridenName"");
  })
  .to(""azure-storage-blob://camelazure/container1?operation=deleteBlobContainer&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `listBlobs`:

[source,java]
--------------------------------------------------------------------------------
from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_CONTAINER_NAME, ""overridenName"");
  })
  .to(""azure-storage-blob://camelazure/container1?operation=listBlobs&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------


- `getBlob`:

We can either set an `outputStream` in the exchange body and write the data to it. E.g:
[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_CONTAINER_NAME, ""overridenName"");

    // set our body
    exchange.getIn().setBody(outputStream);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=getBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

If we don't set a body, then this operation will give us an `InputStream` instance which can proceeded further downstream:

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=getBlob&serviceClient=#client"")
  .process(exchange -> {
      InputStream inputStream = exchange.getMessage().getBody(InputStream.class);
      // We use Apache common IO for simplicity, but you are free to do whatever dealing
      // with inputStream
      System.out.println(IOUtils.toString(inputStream, StandardCharsets.UTF_8.name()));
  })
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `deleteBlob`:

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_NAME, ""overridenName"");
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=deleteBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `downloadBlobToFile`:

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_NAME, ""overridenName"");
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=downloadBlobToFile&fileDir=/var/mydir&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `downloadLink`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=downloadLink&serviceClient=#client"")
  .process(exchange -> {
      String link = exchange.getMessage().getHeader(BlobConstants.DOWNLOAD_LINK, String.class);
      System.out.println(""My link "" + link);
  })
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `uploadBlockBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    // set the header you want the producer to evaluate, refer to the previous
    // section to learn about the headers that can be set
    // e.g:
    exchange.getIn().setHeader(BlobConstants.BLOB_NAME, ""overridenName"");
    exchange.getIn().setBody(""Block Blob"");
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=uploadBlockBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `stageBlockBlobList`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
      final List<BlobBlock> blocks = new LinkedList<>();
      blocks.add(BlobBlock.createBlobBlock(new ByteArrayInputStream(""Hello"".getBytes())));
      blocks.add(BlobBlock.createBlobBlock(new ByteArrayInputStream(""From"".getBytes())));
      blocks.add(BlobBlock.createBlobBlock(new ByteArrayInputStream(""Camel"".getBytes())));

      exchange.getIn().setBody(blocks);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=stageBlockBlobList&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `commitBlockBlobList`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
      // We assume here you have the knowledge of these blocks you want to commit
      final List<Block> blocksIds = new LinkedList<>();
      blocksIds.add(new Block().setName(""id-1""));
      blocksIds.add(new Block().setName(""id-2""));
      blocksIds.add(new Block().setName(""id-3""));

      exchange.getIn().setBody(blocksIds);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=commitBlockBlobList&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `getBlobBlockList`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=getBlobBlockList&serviceClient=#client"")
  .log(""${body}"")
  .to(""mock:result"");
--------------------------------------------------------------------------------


- `createAppendBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=createAppendBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `commitAppendBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    final String data = ""Hello world from my awesome tests!"";
    final InputStream dataStream = new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8));

    exchange.getIn().setBody(dataStream);

    // of course you can set whatever headers you like, refer to the headers section to learn more
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=commitAppendBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `createPageBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=createPageBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `uploadPageBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    byte[] dataBytes = new byte[512]; // we set range for the page from 0-511
    new Random().nextBytes(dataBytes);
    final InputStream dataStream = new ByteArrayInputStream(dataBytes);
    final PageRange pageRange = new PageRange().setStart(0).setEnd(511);

    exchange.getIn().setHeader(BlobConstants.PAGE_BLOB_RANGE, pageRange);
    exchange.getIn().setBody(dataStream);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=uploadPageBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `resizePageBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    final PageRange pageRange = new PageRange().setStart(0).setEnd(511);

    exchange.getIn().setHeader(BlobConstants.PAGE_BLOB_RANGE, pageRange);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=resizePageBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `clearPageBlob`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    final PageRange pageRange = new PageRange().setStart(0).setEnd(511);

    exchange.getIn().setHeader(BlobConstants.PAGE_BLOB_RANGE, pageRange);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=clearPageBlob&serviceClient=#client"")
  .to(""mock:result"");
--------------------------------------------------------------------------------

- `getPageBlobRanges`

[source,java]
--------------------------------------------------------------------------------

from(""direct:start"")
  .process(exchange -> {
    final PageRange pageRange = new PageRange().setStart(0).setEnd(511);

    exchange.getIn().setHeader(BlobConstants.PAGE_BLOB_RANGE, pageRange);
  })
  .to(""azure-storage-blob://camelazure/container1?blobName=blob&operation=getPageBlobRanges&serviceClient=#client"")
  .log(""${body}"")
  .to(""mock:result"");
--------------------------------------------------------------------------------


=== Development Notes (Important)
All integration tests use [Testcontainers](https://www.testcontainers.org/) and run by default.
Obtaining of Azure accessKey and accountName is needed to be able to run all integration tests using Azure services.
In addition to the mocked unit tests you *will need to run the integration tests
with every change you make or even client upgrade as the Azure client can break things even on minor versions upgrade.*
To run the integration tests, on this component directory, run the following maven command:
----
mvn verify -PfullTests -DaccountName=myacc -DaccessKey=mykey
----
Whereby `accountName` is your Azure account name and `accessKey` is the access key being generated from Azure portal.


include::{page-component-version}@camel-spring-boot::page$azure-storage-blob-starter.adoc[]
",12099,False,2177.48589658048,median
"#pragma once 
#include <Register/Utility.hpp>
namespace Kvasir {
//Analog comparators ACMP0/1/2/3
    namespace AcmpCtrl{    ///<Comparator block control register
        using Addr = Register::Address<0x40008000,0x00000000,0x00000000,unsigned>;
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,0),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Selects the which comparators set and reset the ROSC output.
        enum class RoscctlVal {
            acmp1Acmp0=0x00000000,     ///<ACMP1/ACMP0. The ROSC output is set by ACMP1 and reset by ACMP0.
            acmp0Acmp1=0x00000001,     ///<ACMP0/ACMP1. The ROSC output is set by ACMP0 and reset by ACMP1.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::ReadWriteAccess,RoscctlVal> roscctl{}; 
        namespace RoscctlValC{
            constexpr Register::FieldValue<decltype(roscctl)::Type,RoscctlVal::acmp1Acmp0> acmp1Acmp0{};
            constexpr Register::FieldValue<decltype(roscctl)::Type,RoscctlVal::acmp0Acmp1> acmp0Acmp1{};
        }
        ///Selects the reset source for the ROSC output.
        enum class ExtresetVal {
            internal=0x00000000,     ///<Internal. The ROSC output is reset by the internal chip reset.
            fromPinRoscReset=0x00000001,     ///<From pin ROSC_RESET. The ROSC output is reset by the ROSC_RESET input.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(9,9),Register::ReadWriteAccess,ExtresetVal> extReset{}; 
        namespace ExtresetValC{
            constexpr Register::FieldValue<decltype(extReset)::Type,ExtresetVal::internal> internal{};
            constexpr Register::FieldValue<decltype(extReset)::Type,ExtresetVal::fromPinRoscReset> fromPinRoscReset{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,10),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmp0{    ///<Comparator 0 source control
        using Addr = Register::Address<0x40008004,0x00000000,0x00000000,unsigned>;
        ///Comparator enable control.
        enum class EnVal {
            disabled=0x00000000,     ///<Disabled. Comparator disabled.
            enabled=0x00000001,     ///<Enabled. Comparator is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,EnVal> en{}; 
        namespace EnValC{
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Interrupt enable.
        enum class IntenVal {
            disabled=0x00000000,     ///<Disabled. Interrupts are disabled..
            enabled=0x00000001,     ///<Enabled. Interrupts are enabled.. Must set to 1 for interrupts to propagate to the NVIC and start-up logic.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,IntenVal> inten{}; 
        namespace IntenValC{
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::enabled> enabled{};
        }
        ///Comparator status. This bit reflects the comparator output
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,unsigned> stat{}; 
        ///VM input select.
        enum class VmVal {
            vrefDivider0=0x00000000,     ///<Vref divider 0.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp0I3=0x00000003,     ///<ACMP0_I3.
            acmp0I4=0x00000004,     ///<ACMP0_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            tempSensor=0x00000006,     ///<Temp sensor.
            adc02=0x00000007,     ///<ADC0_2. Input for ADC0 channel 2.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::ReadWriteAccess,VmVal> vm{}; 
        namespace VmValC{
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::vrefDivider0> vrefDivider0{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp0I3> acmp0I3{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp0I4> acmp0I4{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::tempSensor> tempSensor{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc02> adc02{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///VP input select.
        enum class VpVal {
            vrefDivider0=0x00000000,     ///<Vref divider 0.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp0I3=0x00000003,     ///<ACMP0_I3.
            acmp0I4=0x00000004,     ///<ACMP0_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            tempSensor=0x00000006,     ///<Temp sensor.
            adc02=0x00000007,     ///<ADC0_2. Input for ADC0 channel 2.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,8),Register::ReadWriteAccess,VpVal> vp{}; 
        namespace VpValC{
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::vrefDivider0> vrefDivider0{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp0I3> acmp0I3{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp0I4> acmp0I4{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::tempSensor> tempSensor{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc02> adc02{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,11),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Hysteresis control. When enabled, hysteresis determines the difference required between the comparator inputs before the comparator output switches. The difference must be in the direction opposite of the current comparator output.
        enum class HysVal {
            hysteresisIsTurned=0x00000000,     ///<Hysteresis is turned off, comparator output will change as the input voltages cross.
            hysteresisEq5Mv=0x00000001,     ///<Hysteresis = 5 mV.
            hysteresisEq10Mv=0x00000002,     ///<Hysteresis = 10 mV.
            hysteresisEq15Mv=0x00000003,     ///<Hysteresis = 15 mV.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,13),Register::ReadWriteAccess,HysVal> hys{}; 
        namespace HysValC{
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisIsTurned> hysteresisIsTurned{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq5Mv> hysteresisEq5Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq10Mv> hysteresisEq10Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq15Mv> hysteresisEq15Mv{};
        }
        ///Selects the polarity of the CMP output for purposes of generating level interrupts.
        enum class IntpolVal {
            notInverted=0x00000000,     ///<Not inverted. The output is used as-is for generating interrupts.
            inverted=0x00000001,     ///<Inverted. The output is used inverted for generating interrupts.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,15),Register::ReadWriteAccess,IntpolVal> intpol{}; 
        namespace IntpolValC{
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::notInverted> notInverted{};
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::inverted> inverted{};
        }
        ///Select interrupt type.
        enum class InttypeVal {
            edge=0x00000000,     ///<Edge. Comparator interrupt is edge triggered.
            level=0x00000001,     ///<Level. Comparator interrupt is level triggered.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::ReadWriteAccess,InttypeVal> inttype{}; 
        namespace InttypeValC{
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::edge> edge{};
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::level> level{};
        }
        ///Select edge triggered interrupt to be active on either high or low transitions, when INTTYPE = 0.
        enum class IntedgeVal {
            falling=0x00000000,     ///<Falling. Comparator interrupt is active on falling edges.
            rising=0x00000001,     ///<Rising. Comparator interrupt is active on rising edges.
            bothEdges=0x00000002,     ///<Both edges. Comparator Interrupt is active on both edges.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,17),Register::ReadWriteAccess,IntedgeVal> intedge{}; 
        namespace IntedgeValC{
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::falling> falling{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::rising> rising{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::bothEdges> bothEdges{};
        }
        ///Interrupt flag.
        enum class IntflagVal {
            notPending=0x00000000,     ///<Not pending. The Comparator interrupt is not pending.
            pending=0x00000001,     ///<Pending. The Comparator interrupt is pending. Writing a 1 to this bit clears the flag.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,IntflagVal> intflag{}; 
        namespace IntflagValC{
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::notPending> notPending{};
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::pending> pending{};
        }
        ///Voltage ladder enable for comparator 0.
        enum class VladenVal {
            disabled=0x00000000,     ///<Disabled. The Comparator voltage ladder is disabled.
            enabled=0x00000001,     ///<Enabled. The Comparator voltage ladder is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,VladenVal> vladen{}; 
        namespace VladenValC{
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage reference select for comparator 0 voltage ladder.
        enum class VladrefVal {
            vrefCmpPin=0x00000000,     ///<VREF_CMP pin.
            vddaPin=0x00000001,     ///<VDDA pin.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::ReadWriteAccess,VladrefVal> vladref{}; 
        namespace VladrefValC{
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vrefCmpPin> vrefCmpPin{};
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vddaPin> vddaPin{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage ladder value for comparator 0. The reference voltage Vref depends on the setting of VLADREF (either VDD(3V3) or voltage on pin VREF_CMP). 00000 = Vss. 00001 = 1 x Vref / 31. 00010 = 2 x Vref / 31. ... 11111 = Vref
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,24),Register::ReadWriteAccess,unsigned> vsel{}; 
        ///Configure the propagation delay. A shorter propagation delay means higher power consumption. Use values from 0x0 (shortest propagation delay and highest power consumption) to 0x2 (longest propagation delay and lowest power consumption). See the  data sheet for details.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,29),Register::ReadWriteAccess,unsigned> dly{}; 
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmp1{    ///<Comparator 1 source control
        using Addr = Register::Address<0x4000800c,0x00000000,0x00000000,unsigned>;
        ///Comparator enable control.
        enum class EnVal {
            disabled=0x00000000,     ///<Disabled. Comparator disabled.
            enabled=0x00000001,     ///<Enabled. Comparator is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,EnVal> en{}; 
        namespace EnValC{
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Interrupt enable.
        enum class IntenVal {
            disabled=0x00000000,     ///<Disabled. Interrupts are disabled..
            enabled=0x00000001,     ///<Enabled. Interrupts are enabled.. Must set to 1 for interrupts to propagate to the NVIC and start-up logic.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,IntenVal> inten{}; 
        namespace IntenValC{
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::enabled> enabled{};
        }
        ///Comparator status. This bit reflects the comparator output
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,unsigned> stat{}; 
        ///VM input select.
        enum class VmVal {
            vrefDivider1=0x00000000,     ///<Vref divider 1.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp1I3=0x00000003,     ///<ACMP1_I3.
            acmp1I4=0x00000004,     ///<ACMP1_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            adc01=0x00000006,     ///<ADC0_1. Input for ADC0 channel 1.
            adc03=0x00000007,     ///<ADC0_3. Input for ADC0 channel 3.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::ReadWriteAccess,VmVal> vm{}; 
        namespace VmValC{
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::vrefDivider1> vrefDivider1{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp1I3> acmp1I3{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp1I4> acmp1I4{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc01> adc01{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc03> adc03{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///VP input select.
        enum class VpVal {
            vrefDivider1=0x00000000,     ///<Vref divider 1.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp1I3=0x00000003,     ///<ACMP1_I3.
            acmp1I4=0x00000004,     ///<ACMP1_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            adc01=0x00000006,     ///<ADC0_1. Input for ADC0 channel 1.
            adc03=0x00000007,     ///<ADC0_3. Input for ADC0 channel 3.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,8),Register::ReadWriteAccess,VpVal> vp{}; 
        namespace VpValC{
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::vrefDivider1> vrefDivider1{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp1I3> acmp1I3{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp1I4> acmp1I4{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc01> adc01{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc03> adc03{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,11),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Hysteresis control. When enabled, hysteresis determines the difference required between the comparator inputs before the comparator output switches. The difference must be in the direction opposite of the current comparator output.
        enum class HysVal {
            hysteresisIsTurned=0x00000000,     ///<Hysteresis is turned off, comparator output will change as the input voltages cross.
            hysteresisEq5Mv=0x00000001,     ///<Hysteresis = 5 mV.
            hysteresisEq10Mv=0x00000002,     ///<Hysteresis = 10 mV.
            hysteresisEq15Mv=0x00000003,     ///<Hysteresis = 15 mV.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,13),Register::ReadWriteAccess,HysVal> hys{}; 
        namespace HysValC{
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisIsTurned> hysteresisIsTurned{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq5Mv> hysteresisEq5Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq10Mv> hysteresisEq10Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq15Mv> hysteresisEq15Mv{};
        }
        ///Selects the polarity of the CMP output for purposes of generating level interrupts.
        enum class IntpolVal {
            notInverted=0x00000000,     ///<Not inverted. The output is used as-is for generating interrupts.
            inverted=0x00000001,     ///<Inverted. The output is used inverted for generating interrupts.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,15),Register::ReadWriteAccess,IntpolVal> intpol{}; 
        namespace IntpolValC{
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::notInverted> notInverted{};
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::inverted> inverted{};
        }
        ///Select interrupt type.
        enum class InttypeVal {
            edge=0x00000000,     ///<Edge. Comparator interrupt is edge triggered.
            level=0x00000001,     ///<Level. Comparator interrupt is level triggered.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::ReadWriteAccess,InttypeVal> inttype{}; 
        namespace InttypeValC{
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::edge> edge{};
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::level> level{};
        }
        ///Select edge triggered interrupt to be active on either high or low transitions, when INTTYPE = 0.
        enum class IntedgeVal {
            falling=0x00000000,     ///<Falling. Comparator interrupt is active on falling edges.
            rising=0x00000001,     ///<Rising. Comparator interrupt is active on rising edges.
            bothEdges=0x00000002,     ///<Both edges. Comparator Interrupt is active on both edges.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,17),Register::ReadWriteAccess,IntedgeVal> intedge{}; 
        namespace IntedgeValC{
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::falling> falling{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::rising> rising{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::bothEdges> bothEdges{};
        }
        ///Interrupt flag.
        enum class IntflagVal {
            notPending=0x00000000,     ///<Not pending. The Comparator interrupt is not pending.
            pending=0x00000001,     ///<Pending. The Comparator interrupt is pending. Writing a 1 to this bit clears the flag.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,IntflagVal> intflag{}; 
        namespace IntflagValC{
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::notPending> notPending{};
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::pending> pending{};
        }
        ///Voltage ladder enable for comparator 1.
        enum class VladenVal {
            disabled=0x00000000,     ///<Disabled. The Comparator voltage ladder is disabled.
            enabled=0x00000001,     ///<Enabled. The Comparator voltage ladder is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,VladenVal> vladen{}; 
        namespace VladenValC{
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage reference select for comparator 1 voltage ladder.
        enum class VladrefVal {
            vrefCmpPin=0x00000000,     ///<VREF_CMP pin.
            vddaPin=0x00000001,     ///<VDDA pin.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::ReadWriteAccess,VladrefVal> vladref{}; 
        namespace VladrefValC{
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vrefCmpPin> vrefCmpPin{};
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vddaPin> vddaPin{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage ladder value for comparator 1. The reference voltage Vref depends on the setting of VLADREF (either VDD(3V3) or voltage on pin VREF_CMP). 00000 = Vss. 00001 = 1 x Vref / 31. 00010 = 2 x Vref / 31. ... 11111 = Vref
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,24),Register::ReadWriteAccess,unsigned> vsel{}; 
        ///Configure the propagation delay. A shorter propagation delay means higher power consumption. Use values from 0x0 (shortest propagation delay and highest power consumption) to 0x2 (longest propagation delay and lowest power consumption). See the  data sheet for details.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,29),Register::ReadWriteAccess,unsigned> dly{}; 
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmp2{    ///<Comparator 2 source control
        using Addr = Register::Address<0x40008014,0x00000000,0x00000000,unsigned>;
        ///Comparator enable control.
        enum class EnVal {
            disabled=0x00000000,     ///<Disabled. Comparator disabled.
            enabled=0x00000001,     ///<Enabled. Comparator is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,EnVal> en{}; 
        namespace EnValC{
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Interrupt enable.
        enum class IntenVal {
            disabled=0x00000000,     ///<Disabled. Interrupts are disabled..
            enabled=0x00000001,     ///<Enabled. Interrupts are enabled.. Must set to 1 for interrupts to propagate to the NVIC and start-up logic.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,IntenVal> inten{}; 
        namespace IntenValC{
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::enabled> enabled{};
        }
        ///Comparator status. This bit reflects the comparator output
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,unsigned> stat{}; 
        ///VM input select.
        enum class VmVal {
            vrefDivider2=0x00000000,     ///<Vref divider 2.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp2I3=0x00000003,     ///<ACMP2_I3.
            acmp2I4=0x00000004,     ///<ACMP2_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            adc00=0x00000006,     ///<ADC0_0. Input for ADC0 channel 0.
            adc12=0x00000007,     ///<ADC1_2. Input for ADC1 channel 2.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::ReadWriteAccess,VmVal> vm{}; 
        namespace VmValC{
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::vrefDivider2> vrefDivider2{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp2I3> acmp2I3{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp2I4> acmp2I4{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc00> adc00{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc12> adc12{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///VP input select.
        enum class VpVal {
            vrefDivider2=0x00000000,     ///<Vref divider 2.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp2I3=0x00000003,     ///<ACMP2_I3.
            acmp2I4=0x00000004,     ///<ACMP2_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            adc00=0x00000006,     ///<ADC0_0. Input for ADC0 channel 0.
            adc12=0x00000007,     ///<ADC1_2. Input for ADC1 channel 2.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,8),Register::ReadWriteAccess,VpVal> vp{}; 
        namespace VpValC{
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::vrefDivider2> vrefDivider2{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp2I3> acmp2I3{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp2I4> acmp2I4{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc00> adc00{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc12> adc12{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,11),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Hysteresis control. When enabled, hysteresis determines the difference required between the comparator inputs before the comparator output switches. The difference must be in the direction opposite of the current comparator output.
        enum class HysVal {
            hysteresisIsTurned=0x00000000,     ///<Hysteresis is turned off, comparator output will change as the input voltages cross.
            hysteresisEq5Mv=0x00000001,     ///<Hysteresis = 5 mV.
            hysteresisEq10Mv=0x00000002,     ///<Hysteresis = 10 mV.
            hysteresisEq15Mv=0x00000003,     ///<Hysteresis = 15 mV.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,13),Register::ReadWriteAccess,HysVal> hys{}; 
        namespace HysValC{
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisIsTurned> hysteresisIsTurned{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq5Mv> hysteresisEq5Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq10Mv> hysteresisEq10Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq15Mv> hysteresisEq15Mv{};
        }
        ///Selects the polarity of the CMP output for purposes of generating level interrupts.
        enum class IntpolVal {
            notInverted=0x00000000,     ///<Not inverted. The output is used as-is for generating interrupts.
            inverted=0x00000001,     ///<Inverted. The output is used inverted for generating interrupts.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,15),Register::ReadWriteAccess,IntpolVal> intpol{}; 
        namespace IntpolValC{
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::notInverted> notInverted{};
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::inverted> inverted{};
        }
        ///Select interrupt type.
        enum class InttypeVal {
            edge=0x00000000,     ///<Edge. Comparator interrupt is edge triggered.
            level=0x00000001,     ///<Level. Comparator interrupt is level triggered.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::ReadWriteAccess,InttypeVal> inttype{}; 
        namespace InttypeValC{
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::edge> edge{};
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::level> level{};
        }
        ///Select edge triggered interrupt to be active on either high or low transitions, when INTTYPE = 0.
        enum class IntedgeVal {
            falling=0x00000000,     ///<Falling. Comparator interrupt is active on falling edges.
            rising=0x00000001,     ///<Rising. Comparator interrupt is active on rising edges.
            bothEdges=0x00000002,     ///<Both edges. Comparator Interrupt is active on both edges.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,17),Register::ReadWriteAccess,IntedgeVal> intedge{}; 
        namespace IntedgeValC{
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::falling> falling{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::rising> rising{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::bothEdges> bothEdges{};
        }
        ///Interrupt flag.
        enum class IntflagVal {
            notPending=0x00000000,     ///<Not pending. The Comparator interrupt is not pending.
            pending=0x00000001,     ///<Pending. The Comparator interrupt is pending. Writing a 1 to this bit clears the flag.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,IntflagVal> intflag{}; 
        namespace IntflagValC{
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::notPending> notPending{};
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::pending> pending{};
        }
        ///Voltage ladder enable for comparator 2.
        enum class VladenVal {
            disabled=0x00000000,     ///<Disabled. The Comparator voltage ladder is disabled.
            enabled=0x00000001,     ///<Enabled. The Comparator voltage ladder is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,VladenVal> vladen{}; 
        namespace VladenValC{
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage reference select for comparator 2 voltage ladder.
        enum class VladrefVal {
            vrefCmpPin=0x00000000,     ///<VREF_CMP pin.
            vddaPin=0x00000001,     ///<VDDA pin.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::ReadWriteAccess,VladrefVal> vladref{}; 
        namespace VladrefValC{
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vrefCmpPin> vrefCmpPin{};
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vddaPin> vddaPin{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage ladder value for comparator 2. The reference voltage Vref depends on the setting of VLADREF (either VDD(3V3) or voltage on pin VREF_CMP). 00000 = Vss. 00001 = 1 x Vref / 31. 00010 = 2 x Vref / 31. ... 11111 = Vref
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,24),Register::ReadWriteAccess,unsigned> vsel{}; 
        ///Configure the propagation delay. A shorter propagation delay means higher power consumption. Use values from 0x0 (shortest propagation delay and highest power consumption) to 0x2 (longest propagation delay and lowest power consumption). See the  data sheet for details.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,29),Register::ReadWriteAccess,unsigned> dly{}; 
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmp3{    ///<Comparator 3 source control
        using Addr = Register::Address<0x4000801c,0x00000000,0x00000000,unsigned>;
        ///Comparator enable control.
        enum class EnVal {
            disabled=0x00000000,     ///<Disabled. Comparator disabled.
            enabled=0x00000001,     ///<Enabled. Comparator is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,EnVal> en{}; 
        namespace EnValC{
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(en)::Type,EnVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Interrupt enable.
        enum class IntenVal {
            disabled=0x00000000,     ///<Disabled. Interrupts are disabled..
            enabled=0x00000001,     ///<Enabled. Interrupts are enabled.. Must set to 1 for interrupts to propagate to the NVIC and start-up logic.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,IntenVal> inten{}; 
        namespace IntenValC{
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(inten)::Type,IntenVal::enabled> enabled{};
        }
        ///Comparator status. This bit reflects the comparator output
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,unsigned> stat{}; 
        ///VM input select.
        enum class VmVal {
            vrefDivider3=0x00000000,     ///<Vref divider 3.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp3I3=0x00000003,     ///<ACMP3_I3.
            acmp3I4=0x00000004,     ///<ACMP3_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            adc11=0x00000006,     ///<ADC1_1. Input for ADC1 channel 1.
            adc13=0x00000007,     ///<ADC1_3. Input for ADC1 channel 3.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,4),Register::ReadWriteAccess,VmVal> vm{}; 
        namespace VmValC{
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::vrefDivider3> vrefDivider3{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp3I3> acmp3I3{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::acmp3I4> acmp3I4{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc11> adc11{};
            constexpr Register::FieldValue<decltype(vm)::Type,VmVal::adc13> adc13{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///VP input select.
        enum class VpVal {
            vrefDivider3=0x00000000,     ///<Vref divider 3.
            acmpI1=0x00000001,     ///<ACMP_I1.
            acmpI2=0x00000002,     ///<ACMP_I2.
            acmp3I3=0x00000003,     ///<ACMP3_I3.
            acmp3I4=0x00000004,     ///<ACMP3_I4.
            internal0=0x00000005,     ///<Internal 0.9 V band gap reference.
            adc11=0x00000006,     ///<ADC1_1. Input for ADC1 channel 1.
            adc13=0x00000007,     ///<ADC1_3. Input for ADC1 channel 3.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,8),Register::ReadWriteAccess,VpVal> vp{}; 
        namespace VpValC{
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::vrefDivider3> vrefDivider3{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI1> acmpI1{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmpI2> acmpI2{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp3I3> acmp3I3{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::acmp3I4> acmp3I4{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::internal0> internal0{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc11> adc11{};
            constexpr Register::FieldValue<decltype(vp)::Type,VpVal::adc13> adc13{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,11),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Hysteresis control. When enabled, hysteresis determines the difference required between the comparator inputs before the comparator output switches. The difference must be in the direction opposite of the current comparator output.
        enum class HysVal {
            hysteresisIsTurned=0x00000000,     ///<Hysteresis is turned off, comparator output will change as the input voltages cross.
            hysteresisEq5Mv=0x00000001,     ///<Hysteresis = 5 mV.
            hysteresisEq10Mv=0x00000002,     ///<Hysteresis = 10 mV.
            hysteresisEq15Mv=0x00000003,     ///<Hysteresis = 15 mV.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,13),Register::ReadWriteAccess,HysVal> hys{}; 
        namespace HysValC{
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisIsTurned> hysteresisIsTurned{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq5Mv> hysteresisEq5Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq10Mv> hysteresisEq10Mv{};
            constexpr Register::FieldValue<decltype(hys)::Type,HysVal::hysteresisEq15Mv> hysteresisEq15Mv{};
        }
        ///Selects the polarity of the CMP output for purposes of generating level interrupts.
        enum class IntpolVal {
            notInverted=0x00000000,     ///<Not inverted. The output is used as-is for generating interrupts.
            inverted=0x00000001,     ///<Inverted. The output is used inverted for generating interrupts.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,15),Register::ReadWriteAccess,IntpolVal> intpol{}; 
        namespace IntpolValC{
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::notInverted> notInverted{};
            constexpr Register::FieldValue<decltype(intpol)::Type,IntpolVal::inverted> inverted{};
        }
        ///Select interrupt type.
        enum class InttypeVal {
            edge=0x00000000,     ///<Edge. Comparator interrupt is edge triggered.
            level=0x00000001,     ///<Level. Comparator interrupt is level triggered.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::ReadWriteAccess,InttypeVal> inttype{}; 
        namespace InttypeValC{
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::edge> edge{};
            constexpr Register::FieldValue<decltype(inttype)::Type,InttypeVal::level> level{};
        }
        ///Select edge triggered interrupt to be active on either high or low transitions, when INTTYPE = 0.
        enum class IntedgeVal {
            falling=0x00000000,     ///<Falling. Comparator interrupt is active on falling edges.
            rising=0x00000001,     ///<Rising. Comparator interrupt is active on rising edges.
            bothEdges=0x00000002,     ///<Both edges. Comparator Interrupt is active on both edges.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,17),Register::ReadWriteAccess,IntedgeVal> intedge{}; 
        namespace IntedgeValC{
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::falling> falling{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::rising> rising{};
            constexpr Register::FieldValue<decltype(intedge)::Type,IntedgeVal::bothEdges> bothEdges{};
        }
        ///Interrupt flag.
        enum class IntflagVal {
            notPending=0x00000000,     ///<Not pending. The Comparator interrupt is not pending.
            pending=0x00000001,     ///<Pending. The Comparator interrupt is pending. Writing a 1 to this bit clears the flag.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,IntflagVal> intflag{}; 
        namespace IntflagValC{
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::notPending> notPending{};
            constexpr Register::FieldValue<decltype(intflag)::Type,IntflagVal::pending> pending{};
        }
        ///Voltage ladder enable for comparator 3.
        enum class VladenVal {
            disabled=0x00000000,     ///<Disabled. The Comparator voltage ladder is disabled.
            enabled=0x00000001,     ///<Enabled. The Comparator voltage ladder is enabled.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,VladenVal> vladen{}; 
        namespace VladenValC{
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::disabled> disabled{};
            constexpr Register::FieldValue<decltype(vladen)::Type,VladenVal::enabled> enabled{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage reference select for comparator 3 voltage ladder.
        enum class VladrefVal {
            vrefCmpPin=0x00000000,     ///<VREF_CMP pin.
            vddaPin=0x00000001,     ///<VDDA pin.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(22,22),Register::ReadWriteAccess,VladrefVal> vladref{}; 
        namespace VladrefValC{
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vrefCmpPin> vrefCmpPin{};
            constexpr Register::FieldValue<decltype(vladref)::Type,VladrefVal::vddaPin> vddaPin{};
        }
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,23),Register::ReadWriteAccess,unsigned> reserved{}; 
        ///Voltage ladder value for comparator 3. The reference voltage Vref depends on the setting of VLADREF (either VDD(3V3) or voltage on pin VREF_CMP). 00000 = Vss. 00001 = 1 x Vref / 31. 00010 = 2 x Vref / 31. ... 11111 = Vref
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,24),Register::ReadWriteAccess,unsigned> vsel{}; 
        ///Configure the propagation delay. A shorter propagation delay means higher power consumption. Use values from 0x0 (shortest propagation delay and highest power consumption) to 0x2 (longest propagation delay and lowest power consumption). See the  data sheet for details.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,29),Register::ReadWriteAccess,unsigned> dly{}; 
        ///Reserved.
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmpfiltr0{    ///<Comparator 0 pin filter set-up
        using Addr = Register::Address<0x40008008,0x00000000,0x00000000,unsigned>;
        ///Digital filter sample mode.
        enum class SmodeVal {
            bypassInputFilter=0x00000000,     ///<Bypass input filter.
            v1ClockCycle=0x00000001,     ///<1 clock cycle. Input pulses shorter than one filter clock are rejected.
            v2ClockCycles=0x00000002,     ///<2 clock cycles. Input pulses shorter than two filter clocks are rejected.
            v3ClockCycles=0x00000003,     ///<3 clock cycles. Input pulses shorter than three filter clocks are rejected.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,SmodeVal> sMode{}; 
        namespace SmodeValC{
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::bypassInputFilter> bypassInputFilter{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v1ClockCycle> v1ClockCycle{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v2ClockCycles> v2ClockCycles{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v3ClockCycles> v3ClockCycles{};
        }
        ///Select clock divider for comparator clock CMP_PCLK.
        enum class ClkdivVal {
            cmpPclk=0x00000000,     ///<CMP_PCLK.
            cmpPclkdiv2=0x00000001,     ///<CMP_PCLK/2.
            cmpPclkdiv4=0x00000002,     ///<CMP_PCLK/4.
            cmpPclkdiv8=0x00000003,     ///<CMP_PCLK/8.
            cmpPclkdiv16=0x00000004,     ///<CMP_PCLK/16.
            cmpPclkdiv32=0x00000005,     ///<CMP_PCLK/32.
            cmpPclkdiv64=0x00000006,     ///<CMP_PCLK/64.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,2),Register::ReadWriteAccess,ClkdivVal> clkdiv{}; 
        namespace ClkdivValC{
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclk> cmpPclk{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv2> cmpPclkdiv2{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv4> cmpPclkdiv4{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv8> cmpPclkdiv8{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv16> cmpPclkdiv16{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv32> cmpPclkdiv32{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv64> cmpPclkdiv64{};
        }
        ///Reserved
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,5),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmpfiltr1{    ///<Comparator 0 pin filter set-up
        using Addr = Register::Address<0x40008010,0x00000000,0x00000000,unsigned>;
        ///Digital filter sample mode.
        enum class SmodeVal {
            bypassInputFilter=0x00000000,     ///<Bypass input filter.
            v1ClockCycle=0x00000001,     ///<1 clock cycle. Input pulses shorter than one filter clock are rejected.
            v2ClockCycles=0x00000002,     ///<2 clock cycles. Input pulses shorter than two filter clocks are rejected.
            v3ClockCycles=0x00000003,     ///<3 clock cycles. Input pulses shorter than three filter clocks are rejected.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,SmodeVal> sMode{}; 
        namespace SmodeValC{
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::bypassInputFilter> bypassInputFilter{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v1ClockCycle> v1ClockCycle{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v2ClockCycles> v2ClockCycles{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v3ClockCycles> v3ClockCycles{};
        }
        ///Select clock divider for comparator clock CMP_PCLK.
        enum class ClkdivVal {
            cmpPclk=0x00000000,     ///<CMP_PCLK.
            cmpPclkdiv2=0x00000001,     ///<CMP_PCLK/2.
            cmpPclkdiv4=0x00000002,     ///<CMP_PCLK/4.
            cmpPclkdiv8=0x00000003,     ///<CMP_PCLK/8.
            cmpPclkdiv16=0x00000004,     ///<CMP_PCLK/16.
            cmpPclkdiv32=0x00000005,     ///<CMP_PCLK/32.
            cmpPclkdiv64=0x00000006,     ///<CMP_PCLK/64.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,2),Register::ReadWriteAccess,ClkdivVal> clkdiv{}; 
        namespace ClkdivValC{
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclk> cmpPclk{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv2> cmpPclkdiv2{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv4> cmpPclkdiv4{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv8> cmpPclkdiv8{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv16> cmpPclkdiv16{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv32> cmpPclkdiv32{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv64> cmpPclkdiv64{};
        }
        ///Reserved
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,5),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmpfiltr2{    ///<Comparator 0 pin filter set-up
        using Addr = Register::Address<0x40008018,0x00000000,0x00000000,unsigned>;
        ///Digital filter sample mode.
        enum class SmodeVal {
            bypassInputFilter=0x00000000,     ///<Bypass input filter.
            v1ClockCycle=0x00000001,     ///<1 clock cycle. Input pulses shorter than one filter clock are rejected.
            v2ClockCycles=0x00000002,     ///<2 clock cycles. Input pulses shorter than two filter clocks are rejected.
            v3ClockCycles=0x00000003,     ///<3 clock cycles. Input pulses shorter than three filter clocks are rejected.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,SmodeVal> sMode{}; 
        namespace SmodeValC{
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::bypassInputFilter> bypassInputFilter{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v1ClockCycle> v1ClockCycle{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v2ClockCycles> v2ClockCycles{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v3ClockCycles> v3ClockCycles{};
        }
        ///Select clock divider for comparator clock CMP_PCLK.
        enum class ClkdivVal {
            cmpPclk=0x00000000,     ///<CMP_PCLK.
            cmpPclkdiv2=0x00000001,     ///<CMP_PCLK/2.
            cmpPclkdiv4=0x00000002,     ///<CMP_PCLK/4.
            cmpPclkdiv8=0x00000003,     ///<CMP_PCLK/8.
            cmpPclkdiv16=0x00000004,     ///<CMP_PCLK/16.
            cmpPclkdiv32=0x00000005,     ///<CMP_PCLK/32.
            cmpPclkdiv64=0x00000006,     ///<CMP_PCLK/64.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,2),Register::ReadWriteAccess,ClkdivVal> clkdiv{}; 
        namespace ClkdivValC{
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclk> cmpPclk{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv2> cmpPclkdiv2{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv4> cmpPclkdiv4{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv8> cmpPclkdiv8{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv16> cmpPclkdiv16{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv32> cmpPclkdiv32{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv64> cmpPclkdiv64{};
        }
        ///Reserved
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,5),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
    namespace AcmpCmpfiltr3{    ///<Comparator 0 pin filter set-up
        using Addr = Register::Address<0x40008020,0x00000000,0x00000000,unsigned>;
        ///Digital filter sample mode.
        enum class SmodeVal {
            bypassInputFilter=0x00000000,     ///<Bypass input filter.
            v1ClockCycle=0x00000001,     ///<1 clock cycle. Input pulses shorter than one filter clock are rejected.
            v2ClockCycles=0x00000002,     ///<2 clock cycles. Input pulses shorter than two filter clocks are rejected.
            v3ClockCycles=0x00000003,     ///<3 clock cycles. Input pulses shorter than three filter clocks are rejected.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,0),Register::ReadWriteAccess,SmodeVal> sMode{}; 
        namespace SmodeValC{
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::bypassInputFilter> bypassInputFilter{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v1ClockCycle> v1ClockCycle{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v2ClockCycles> v2ClockCycles{};
            constexpr Register::FieldValue<decltype(sMode)::Type,SmodeVal::v3ClockCycles> v3ClockCycles{};
        }
        ///Select clock divider for comparator clock CMP_PCLK.
        enum class ClkdivVal {
            cmpPclk=0x00000000,     ///<CMP_PCLK.
            cmpPclkdiv2=0x00000001,     ///<CMP_PCLK/2.
            cmpPclkdiv4=0x00000002,     ///<CMP_PCLK/4.
            cmpPclkdiv8=0x00000003,     ///<CMP_PCLK/8.
            cmpPclkdiv16=0x00000004,     ///<CMP_PCLK/16.
            cmpPclkdiv32=0x00000005,     ///<CMP_PCLK/32.
            cmpPclkdiv64=0x00000006,     ///<CMP_PCLK/64.
        };
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,2),Register::ReadWriteAccess,ClkdivVal> clkdiv{}; 
        namespace ClkdivValC{
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclk> cmpPclk{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv2> cmpPclkdiv2{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv4> cmpPclkdiv4{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv8> cmpPclkdiv8{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv16> cmpPclkdiv16{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv32> cmpPclkdiv32{};
            constexpr Register::FieldValue<decltype(clkdiv)::Type,ClkdivVal::cmpPclkdiv64> cmpPclkdiv64{};
        }
        ///Reserved
        constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,5),Register::ReadWriteAccess,unsigned> reserved{}; 
    }
}
",16203,True,4870.437131957328,median
"[[jpa.repositories]]
= JPA Repositories

This chapter points out the specialties for repository support for JPA. This builds on the core repository support explained in ""`<<repositories>>`"". Make sure you have a sound understanding of the basic concepts explained there.

[[jpa.introduction]]
== Introduction

This section describes the basics of configuring Spring Data JPA through either:

* ""`<<jpa.namespace>>`"" (XML configuration)
* ""`<<jpa.java-config>>`"" (Java configuration)

[[jpa.namespace]]
=== Spring Namespace

The JPA module of Spring Data contains a custom namespace that allows defining repository beans. It also contains certain features and element attributes that are special to JPA. Generally, the JPA repositories can be set up by   using the `repositories` element, as shown in the following example:

.Setting up JPA repositories by using the namespace
====
[source, xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<beans xmlns=""http://www.springframework.org/schema/beans""
  xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
  xmlns:jpa=""http://www.springframework.org/schema/data/jpa""
  xsi:schemaLocation=""http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/data/jpa
    https://www.springframework.org/schema/data/jpa/spring-jpa.xsd"">

  <jpa:repositories base-package=""com.acme.repositories"" />

</beans>
----
====

Using the `repositories` element looks up Spring Data repositories as described in ""`<<repositories.create-instances>>`"". Beyond that, it activates persistence exception translation for all beans annotated with `@Repository`, to let exceptions being thrown by the JPA persistence providers be converted into Spring's `DataAccessException` hierarchy.

[[jpa.namespace.custom-namespace-attributes]]
==== Custom Namespace Attributes
Beyond the default attributes of the `repositories` element, the JPA namespace offers additional attributes to let you gain more detailed control over the setup of the repositories:

.Custom JPA-specific attributes of the `repositories` element
[options = ""autowidth""]
|===============
|`entity-manager-factory-ref`|Explicitly wire the `EntityManagerFactory` to be used with the repositories being detected by the `repositories` element. Usually used if multiple `EntityManagerFactory` beans are used within the application. If not configured, Spring Data automatically looks up the `EntityManagerFactory` bean with the name `entityManagerFactory` in the `ApplicationContext`.
|`transaction-manager-ref`|Explicitly wire the `PlatformTransactionManager` to be used with the repositories being detected by the `repositories` element. Usually only necessary if multiple transaction managers or `EntityManagerFactory` beans have been configured. Default to a single defined `PlatformTransactionManager` inside the current `ApplicationContext`.
|===============

NOTE: Spring Data JPA requires a `PlatformTransactionManager` bean named `transactionManager` to be present if no explicit `transaction-manager-ref` is defined.

[[jpa.java-config]]
=== Annotation-based Configuration
The Spring Data JPA repositories support can be activated not only through an XML namespace but also by using an annotation through JavaConfig, as shown in the following example:

.Spring Data JPA repositories using JavaConfig
====
[source, java]
----
@Configuration
@EnableJpaRepositories
@EnableTransactionManagement
class ApplicationConfig {

  @Bean
  public DataSource dataSource() {

    EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
    return builder.setType(EmbeddedDatabaseType.HSQL).build();
  }

  @Bean
  public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setGenerateDdl(true);

    LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setJpaVendorAdapter(vendorAdapter);
    factory.setPackagesToScan(""com.acme.domain"");
    factory.setDataSource(dataSource());
    return factory;
  }

  @Bean
  public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

    JpaTransactionManager txManager = new JpaTransactionManager();
    txManager.setEntityManagerFactory(entityManagerFactory);
    return txManager;
  }
}
----
====
NOTE: You must create `LocalContainerEntityManagerFactoryBean` and not `EntityManagerFactory` directly, since the former also participates in exception translation mechanisms in addition to creating `EntityManagerFactory`.

The preceding configuration class sets up an embedded HSQL database by using the `EmbeddedDatabaseBuilder` API of `spring-jdbc`. Spring Data then sets up an `EntityManagerFactory` and uses Hibernate as the sample persistence provider. The last infrastructure component declared here is the `JpaTransactionManager`. Finally, the example activates Spring Data JPA repositories by using the `@EnableJpaRepositories` annotation, which essentially carries the same attributes as the XML namespace. If no base package is configured, it uses the one in which the configuration class resides.

[[jpa.bootstrap-mode]]
=== Bootstrap Mode

By default, Spring Data JPA repositories are default Spring beans.
They are singleton scoped and eagerly initialized.
During startup, they already interact with the JPA `EntityManager` for verification and metadata analysis purposes.
Spring Framework supports the initialization of the JPA `EntityManagerFactory` in a background thread because that process usually takes up a significant amount of startup time in a Spring application.
To make use of that background initialization effectively, we need to make sure that JPA repositories are initialized as late as possible.

As of Spring Data JPA 2.1 you can now configure a `BootstrapMode` (either via the `@EnableJpaRepositories` annotation or the XML namespace) that takes the following values:

* `DEFAULT` (default) -- Repositories are instantiated eagerly unless explicitly annotated with `@Lazy`.
The lazification only has effect if no client bean needs an instance of the repository as that will require the initialization of the repository bean.
* `LAZY` -- Implicitly declares all repository beans lazy and also causes lazy initialization proxies to be created to be injected into client beans.
That means, that repositories will not get instantiated if the client bean is simply storing the instance in a field and not making use of the repository during initialization.
Repository instances will be initialized and verified upon first interaction with the repository.
* `DEFERRED` -- Fundamentally the same mode of operation as `LAZY`, but triggering repository initialization in response to an `ContextRefreshedEvent` so that repositories are verified before the application has completely started.

[[jpa.bootstrap-mode.recommendations]]
==== Recommendations

If you're not using asynchronous JPA bootstrap stick with the default bootstrap mode.

In case you bootstrap JPA asynchronously, `DEFERRED` is a reasonable default as it will make sure the Spring Data JPA bootstrap only waits for the `EntityManagerFactory` setup if that itself takes longer than initializing all other application components.
Still, it makes sure that repositories are properly initialized and validated before the application signals it's up.

`LAZY` is a decent choice for testing scenarios and local development.
Once you are pretty sure that repositories can properly bootstrap, or in cases where you are testing other parts of the application, running verification for all repositories might unnecessarily increase the startup time.
The same applies to local development in which you only access parts of the application that might need to have a single repository initialized.

[[jpa.entity-persistence]]
== Persisting Entities

This section describes how to persist (save) entities with Spring Data JPA.

[[jpa.entity-persistence.saving-entites]]
=== Saving Entities

Saving an entity can be performed with the `CrudRepository.save(…)` method. It persists or merges the given entity by using the underlying JPA `EntityManager`. If the entity has not yet been persisted, Spring Data JPA saves the entity with a call to the `entityManager.persist(…)` method. Otherwise, it calls the `entityManager.merge(…)` method.

[[jpa.entity-persistence.saving-entites.strategies]]
==== Entity State-detection Strategies
Spring Data JPA offers the following strategies to detect whether an entity is new or not:

1. Version-Property and Id-Property inspection (*default*):
   By default Spring Data JPA inspects first if there is a Version-property of non-primitive type.
   If there is, the entity is considered new if the value of that property is `null`.
   Without such a Version-property Spring Data JPA inspects the identifier property of the given entity.
   If the identifier property is `null`, then the entity is assumed to be new.
   Otherwise, it is assumed to be not new.
2. Implementing `Persistable`: If an entity implements `Persistable`, Spring Data JPA delegates the new detection to the `isNew(…)` method of the entity. See the link:$$https://docs.spring.io/spring-data/data-commons/docs/current/api/index.html?org/springframework/data/domain/Persistable.html$$[JavaDoc] for details.
3. Implementing `EntityInformation`: You can customize the `EntityInformation` abstraction used in the `SimpleJpaRepository` implementation by creating a subclass of `JpaRepositoryFactory` and overriding the `getEntityInformation(…)` method accordingly. You then have to register the custom implementation of `JpaRepositoryFactory` as a Spring bean. Note that this should be rarely necessary. See the link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/index.html?org/springframework/data/jpa/repository/support/JpaRepositoryFactory.html$$[JavaDoc] for details.

Option 1 is not an option for entities that use manually assigned identifiers and no version attribute as with those the identifier will always be non-`null`.
A common pattern in that scenario is to use a common base class with a transient flag defaulting to indicate a new instance and using JPA lifecycle callbacks to flip that flag on persistence operations:

.A base class for entities with manually assigned identifiers
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractEntity<ID> implements Persistable<ID> {

  @Transient
  private boolean isNew = true; <1>

  @Override
  public boolean isNew() {
    return isNew; <2>
  }

  @PrePersist <3>
  @PostLoad
  void markNotNew() {
    this.isNew = false;
  }

  // More code…
}
----
<1> Declare a flag to hold the new state. Transient so that it's not persisted to the database.
<2> Return the flag in the implementation of `Persistable.isNew()` so that Spring Data repositories know whether to call `EntityManager.persist()` or `….merge()`.
<3> Declare a method using JPA entity callbacks so that the flag is switched to indicate an existing entity after a repository call to `save(…)` or an instance creation by the persistence provider.
====

[[jpa.query-methods]]
== Query Methods

This section describes the various ways to create a query with Spring Data JPA.

[[jpa.sample-app.finders.strategies]]
=== Query Lookup Strategies

The JPA module supports defining a query manually as a String or having it being derived from the method name.

Derived queries with the predicates `IsStartingWith`, `StartingWith`, `StartsWith`, `IsEndingWith`, `EndingWith`, `EndsWith`,
`IsNotContaining`, `NotContaining`, `NotContains`, `IsContaining`, `Containing`, `Contains` the respective arguments for these queries will get sanitized.
This means if the arguments actually contain characters recognized by `LIKE` as wildcards these will get escaped so they match only as literals.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Compare with <<jpa.query.spel-expressions>>.

[[jpa.query-methods.declared-queries]]
==== Declared Queries
Although getting a query derived from the method name is quite convenient, one might face the situation in which either the method name parser does not support the keyword one wants to use or the method name would get unnecessarily ugly. So you can either use JPA named queries through a naming convention (see <<jpa.query-methods.named-queries>> for more information) or rather annotate your query method with `@Query` (see <<jpa.query-methods.at-query>> for details).

[[jpa.query-methods.query-creation]]
=== Query Creation

Generally, the query creation mechanism for JPA works as described in ""`<<repositories.query-methods>>`"". The following example shows what a JPA query method translates into:

.Query creation from method names
====
----
public interface UserRepository extends Repository<User, Long> {

  List<User> findByEmailAddressAndLastname(String emailAddress, String lastname);
}
----
We create a query using the JPA criteria API from this, but, essentially, this translates into the following query: `select u from User u where u.emailAddress = ?1 and u.lastname = ?2`. Spring Data JPA does a property check and traverses nested properties, as described in ""`<<repositories.query-methods.query-property-expressions>>`"".
====

The following table describes the keywords supported for JPA and what a method containing that keyword translates to:

.Supported keywords inside method names
[options = ""header, autowidth""]
|===============
|Keyword|Sample|JPQL snippet
|`Distinct`|`findDistinctByLastnameAndFirstname`|`select distinct ... where x.lastname = ?1 and x.firstname = ?2`
|`And`|`findByLastnameAndFirstname`|`… where x.lastname = ?1 and x.firstname = ?2`
|`Or`|`findByLastnameOrFirstname`|`… where x.lastname = ?1 or x.firstname = ?2`
|`Is`, `Equals`|`findByFirstname`,`findByFirstnameIs`,`findByFirstnameEquals`|`… where x.firstname = ?1`
|`Between`|`findByStartDateBetween`|`… where x.startDate between ?1 and ?2`
|`LessThan`|`findByAgeLessThan`|`… where x.age < ?1`
|`LessThanEqual`|`findByAgeLessThanEqual`|`… where x.age \\<= ?1`
|`GreaterThan`|`findByAgeGreaterThan`|`… where x.age > ?1`
|`GreaterThanEqual`|`findByAgeGreaterThanEqual`|`… where x.age >= ?1`
|`After`|`findByStartDateAfter`|`… where x.startDate > ?1`
|`Before`|`findByStartDateBefore`|`… where x.startDate < ?1`
|`IsNull`, `Null`|`findByAge(Is)Null`|`… where x.age is null`
|`IsNotNull`, `NotNull`|`findByAge(Is)NotNull`|`… where x.age not null`
|`Like`|`findByFirstnameLike`|`… where x.firstname like ?1`
|`NotLike`|`findByFirstnameNotLike`|`… where x.firstname not like ?1`
|`StartingWith`|`findByFirstnameStartingWith`|`… where x.firstname like ?1` (parameter bound with appended `%`)
|`EndingWith`|`findByFirstnameEndingWith`|`… where x.firstname like ?1` (parameter bound with prepended `%`)
|`Containing`|`findByFirstnameContaining`|`… where x.firstname like ?1` (parameter bound wrapped in `%`)
|`OrderBy`|`findByAgeOrderByLastnameDesc`|`… where x.age = ?1 order by x.lastname desc`
|`Not`|`findByLastnameNot`|`… where x.lastname <> ?1`
|`In`|`findByAgeIn(Collection<Age> ages)`|`… where x.age in ?1`
|`NotIn`|`findByAgeNotIn(Collection<Age> ages)`|`… where x.age not in ?1`
|`True`|`findByActiveTrue()`|`… where x.active = true`
|`False`|`findByActiveFalse()`|`… where x.active = false`
|`IgnoreCase`|`findByFirstnameIgnoreCase`|`… where UPPER(x.firstname) = UPPER(?1)`
|===============

NOTE: `In` and `NotIn` also take any subclass of `Collection` as a parameter as well as arrays or varargs. For other syntactical versions of the same logical operator, check ""`<<repository-query-keywords>>`"".

[[jpa.query-methods.named-queries]]
=== Using JPA Named Queries

NOTE: The examples use the `<named-query />` element and `@NamedQuery` annotation. The queries for these configuration elements have to be defined in the JPA query language. Of course, you can use `<named-native-query />` or `@NamedNativeQuery` too. These elements let you define the query in native SQL by losing the database platform independence.

[[jpa.query-methods.named-queries.xml-named-query-definition]]
==== XML Named Query Definition
To use XML configuration, add the necessary `<named-query />` element to the `orm.xml` JPA configuration file located in the `META-INF` folder of your classpath. Automatic invocation of named queries is enabled by using some defined naming convention. For more details, see below.

.XML named query configuration
====
[source, xml]
----
<named-query name=""User.findByLastname"">
  <query>select u from User u where u.lastname = ?1</query>
</named-query>
----
====

The query has a special name that is used to resolve it at runtime.

[[jpa.query-methods.named-queries.annotation-based-configuration]]
==== Annotation-based Configuration
Annotation-based configuration has the advantage of not needing another configuration file to be edited, lowering maintenance effort. You pay for that benefit by the need to recompile your domain class for every new query declaration.

.Annotation-based named query configuration
====
[source, java]
----
@Entity
@NamedQuery(name = ""User.findByEmailAddress"",
  query = ""select u from User u where u.emailAddress = ?1"")
public class User {

}
----
====

[[jpa.query-methods.named-queries.declaring-interfaces]]
==== Declaring Interfaces
To allow these named queries, specify the `UserRepository` as follows:

.Query method declaration in UserRepository
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  User findByEmailAddress(String emailAddress);
}
----
====

Spring Data tries to resolve a call to these methods to a named query, starting with the simple name of the configured domain class, followed by the method name separated by a dot.
So the preceding example would use the named queries defined earlier instead of trying to create a query from the method name.

[[jpa.query-methods.at-query]]
=== Using `@Query`

Using named queries to declare queries for entities is a valid approach and works fine for a small number of queries. As the queries themselves are tied to the Java method that runs them, you can actually bind them directly by using the Spring Data JPA `@Query` annotation rather than annotating them to the domain class. This frees the domain class from persistence specific information and co-locates the query to the repository interface.

Queries annotated to the query method take precedence over queries defined using `@NamedQuery` or named queries declared in `orm.xml`.

The following example shows a query created with the `@Query` annotation:

.Declare query at the query method using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.emailAddress = ?1"")
  User findByEmailAddress(String emailAddress);
}
----
====

[[jpa.query-methods.at-query.advanced-like]]
==== Using Advanced `LIKE` Expressions

The query running mechanism for manually defined queries created with `@Query` allows the definition of advanced `LIKE` expressions inside the query definition, as shown in the following example:

.Advanced `like` expressions in @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname like %?1"")
  List<User> findByFirstnameEndsWith(String firstname);
}
----
====

In the preceding example, the `LIKE` delimiter character (`%`) is recognized, and the query is transformed into a valid JPQL query (removing the `%`). Upon running the query, the parameter passed to the method call gets augmented with the previously recognized `LIKE` pattern.

[[jpa.query-methods.at-query.native]]
==== Native Queries

The `@Query` annotation allows for running native queries by setting the `nativeQuery` flag to true, as shown in the following example:

.Declare a native query at the query method using @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1"", nativeQuery = true)
  User findByEmailAddress(String emailAddress);
}
----

====

NOTE: Spring Data JPA does not currently support dynamic sorting for native queries, because it would have to manipulate the actual query declared, which it cannot do reliably for native SQL. You can, however, use native queries for pagination by specifying the count query yourself, as shown in the following example:

.Declare native count queries for pagination at the query method by using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE LASTNAME = ?1"",
    countQuery = ""SELECT count(*) FROM USERS WHERE LASTNAME = ?1"",
    nativeQuery = true)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----

====

A similar approach also works with named native queries, by adding the `.count` suffix to a copy of your query. You probably need to register a result set mapping for your count query, though.

[[jpa.query-methods.sorting]]
=== Using Sort

Sorting can be done by either providing a `PageRequest` or by using `Sort` directly. The properties actually used within the `Order` instances of `Sort` need to match your domain model, which means they need to resolve to either a property or an alias used within the query. The JPQL defines this as a state field path expression.

NOTE: Using any non-referenceable path expression leads to an `Exception`.

However, using `Sort` together with <<jpa.query-methods.at-query, `@Query`>> lets you sneak in non-path-checked `Order` instances containing functions within the `ORDER BY` clause. This is possible because the `Order` is appended to the given query string. By default, Spring Data JPA rejects any `Order` instance containing function calls, but you can use `JpaSort.unsafe` to add potentially unsafe ordering.

The following example uses `Sort` and `JpaSort`, including an unsafe option on `JpaSort`:

.Using `Sort` and `JpaSort`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.lastname like ?1%"")
  List<User> findByAndSort(String lastname, Sort sort);

  @Query(""select u.id, LENGTH(u.firstname) as fn_len from User u where u.lastname like ?1%"")
  List<Object[]> findByAsArrayAndSort(String lastname, Sort sort);
}

repo.findByAndSort(""lannister"", Sort.by(""firstname""));                <1>
repo.findByAndSort(""stark"", Sort.by(""LENGTH(firstname)""));            <2>
repo.findByAndSort(""targaryen"", JpaSort.unsafe(""LENGTH(firstname)"")); <3>
repo.findByAsArrayAndSort(""bolton"", Sort.by(""fn_len""));               <4>
----
<1> Valid `Sort` expression pointing to property in domain model.
<2> Invalid `Sort` containing function call. Throws Exception.
<3> Valid `Sort` containing explicitly _unsafe_ `Order`.
<4> Valid `Sort` expression pointing to aliased function.
====

[[jpa.named-parameters]]
=== Using Named Parameters

By default, Spring Data JPA uses position-based parameter binding, as described in all the preceding examples. This makes query methods a little error-prone when refactoring regarding the parameter position. To solve this issue, you can use `@Param` annotation to give a method parameter a concrete name and bind the name in the query, as shown in the following example:

.Using named parameters
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname = :firstname or u.lastname = :lastname"")
  User findByLastnameOrFirstname(@Param(""lastname"") String lastname,
                                 @Param(""firstname"") String firstname);
}
----
====

NOTE: The method parameters are switched according to their order in the defined query.

NOTE: As of version 4, Spring fully supports Java 8’s parameter name discovery based on the `-parameters` compiler flag. By using this flag in your build as an alternative to debug information, you can omit the `@Param` annotation for named parameters.

[[jpa.query.spel-expressions]]
=== Using SpEL Expressions

As of Spring Data JPA release 1.4, we support the usage of restricted SpEL template expressions in manually defined queries that are defined with `@Query`. Upon the query being run, these expressions are evaluated against a predefined set of variables. Spring Data JPA supports a variable called `entityName`. Its usage is `select x from #{#entityName} x`. It inserts the `entityName` of the domain type associated with the given repository. The `entityName` is resolved as follows: If the domain type has set the name property on the `@Entity` annotation, it is used. Otherwise, the simple class-name of the domain type is used.

The following example demonstrates one use case for the `+#{#entityName}+` expression in a query string where you want to define a repository interface with a query method and a manually defined query:

.Using SpEL expressions in repository query methods - entityName
====
[source, java]
----
@Entity
public class User {

  @Id
  @GeneratedValue
  Long id;

  String lastname;
}

public interface UserRepository extends JpaRepository<User,Long> {

  @Query(""select u from #{#entityName} u where u.lastname = ?1"")
  List<User> findByLastname(String lastname);
}
----
====

To avoid stating the actual entity name in the query string of a `@Query` annotation, you can use the `+#{#entityName}+` variable.

NOTE: The `entityName` can be customized by using the `@Entity` annotation. Customizations in `orm.xml` are not supported for the SpEL expressions.

Of course, you could have just used `User` in the query declaration directly, but that would require you to change the query as well. The reference to `#entityName` picks up potential future remappings of the `User` class to a different entity name (for example, by using `@Entity(name = ""MyUser"")`.

Another use case for the `#{#entityName}` expression in a query string is if you want to define a generic repository interface with specialized repository interfaces for a concrete domain type. To not repeat the definition of custom query methods on the concrete interfaces, you can use the entity name expression in the query string of the `@Query` annotation in the generic repository interface, as shown in the following example:

.Using SpEL expressions in repository query methods - entityName with inheritance
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractMappedType {
  …
  String attribute
}

@Entity
public class ConcreteType extends AbstractMappedType { … }

@NoRepositoryBean
public interface MappedTypeRepository<T extends AbstractMappedType>
  extends Repository<T, Long> {

  @Query(""select t from #{#entityName} t where t.attribute = ?1"")
  List<T> findAllByAttribute(String attribute);
}

public interface ConcreteRepository
  extends MappedTypeRepository<ConcreteType> { … }
----
====

In the preceding example, the `MappedTypeRepository` interface is the common parent interface for a few domain types extending `AbstractMappedType`. It also defines the generic `findAllByAttribute(…)` method, which can be used on instances of the specialized repository interfaces. If you now invoke `findByAllAttribute(…)` on `ConcreteRepository`, the query becomes `select t from ConcreteType t where t.attribute = ?1`.

SpEL expressions to manipulate arguments may also be used to manipulate method arguments.
In these SpEL expressions the entity name is not available, but the arguments are.
They can be accessed by name or index as demonstrated in the following example.

.Using SpEL expressions in repository query methods - accessing arguments.
====
[source, java]
----
@Query(""select u from User u where u.firstname = ?1 and u.firstname=?#{[0]} and u.emailAddress = ?#{principal.emailAddress}"")
List<User> findByFirstnameAndCurrentUserWithCustomQuery(String firstname);
----
====

For `like`-conditions one often wants to append `%` to the beginning or the end of a String valued parameter.
This can be done by appending or prefixing a bind parameter marker or a SpEL expression with `%`.
Again the following example demonstrates this.

.Using SpEL expressions in repository query methods - wildcard shortcut.
====
[source, java]
----
@Query(""select u from User u where u.lastname like %:#{[0]}% and u.lastname like %:lastname%"")
List<User> findByLastnameWithSpelExpression(@Param(""lastname"") String lastname);
----
====

When using `like`-conditions with values that are coming from a not secure source the values should be sanitized so they can't contain any wildcards and thereby allow attackers to select more data than they should be able to.
For this purpose the `escape(String)` method is made available in the SpEL context.
It prefixes all instances of `_` and `%` in the first argument with the single character from the second argument.
In combination with the `escape` clause of the `like` expression available in JPQL and standard SQL this allows easy cleaning of bind parameters.


.Using SpEL expressions in repository query methods - sanitizing input values.
====
[source, java]
----
@Query(""select u from User u where u.firstname like %?#{escape([0])}% escape ?#{escapeCharacter()}"")
List<User> findContainingEscaped(String namePart);
----
====

Given this method declaration in a repository interface `findContainingEscaped(""Peter_"")` will find `Peter_Parker` but not `Peter Parker`.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Note that the method `escape(String)` available in the SpEL context will only escape the SQL and JPQL standard wildcards `_` and `%`.
If the underlying database or the JPA implementation supports additional wildcards these will not get escaped.

[[jpa.modifying-queries]]
=== Modifying Queries

All the previous sections describe how to declare queries to access a given entity or collection of entities.
You can add custom modifying behavior by using the custom method facilities described in ""`<<repositories.custom-implementations>>`"".
As this approach is feasible for comprehensive custom functionality, you can modify queries that only need parameter binding by annotating the query method with `@Modifying`, as shown in the following example:

.Declaring manipulating queries
====
[source, java]
----
@Modifying
@Query(""update User u set u.firstname = ?1 where u.lastname = ?2"")
int setFixedFirstnameFor(String firstname, String lastname);
----
====

Doing so triggers the query annotated to the method as an updating query instead of a selecting one. As the `EntityManager` might contain outdated entities after the execution of the modifying query, we do not automatically clear it (see the https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManager.html[JavaDoc] of `EntityManager.clear()` for details), since this effectively drops all non-flushed changes still pending in the `EntityManager`.
If you wish the `EntityManager` to be cleared automatically, you can set the `@Modifying` annotation's `clearAutomatically` attribute to `true`.

The `@Modifying` annotation is only relevant in combination with the `@Query` annotation.
Derived query methods or custom methods do not require this annotation.

[[jpa.modifying-queries.derived-delete]]
==== Derived Delete Queries
Spring Data JPA also supports derived delete queries that let you avoid having to declare the JPQL query explicitly, as shown in the following example:

.Using a derived delete query
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  void deleteByRoleId(long roleId);

  @Modifying
  @Query(""delete from User u where u.role.id = ?1"")
  void deleteInBulkByRoleId(long roleId);
}
----
====

Although the `deleteByRoleId(…)` method looks like it basically produces the same result as the `deleteInBulkByRoleId(…)`, there is an important difference between the two method declarations in terms of the way they are run.
As the name suggests, the latter method issues a single JPQL query (the one defined in the annotation) against the database.
This means even currently loaded instances of `User` do not see lifecycle callbacks invoked.

To make sure lifecycle queries are actually invoked, an invocation of `deleteByRoleId(…)` runs a query and then deletes the returned instances one by one, so that the persistence provider can actually invoke `@PreRemove` callbacks on those entities.

In fact, a derived delete query is a shortcut for running the query and then calling `CrudRepository.delete(Iterable<User> users)` on the result and keeping behavior in sync with the implementations of other `delete(…)` methods in `CrudRepository`.

[[jpa.query-hints]]
=== Applying Query Hints
To apply JPA query hints to the queries declared in your repository interface, you can use the `@QueryHints` annotation. It takes an array of JPA `@QueryHint` annotations plus a boolean flag to potentially disable the hints applied to the additional count query triggered when applying pagination, as shown in the following example:

.Using QueryHints with a repository method
====
[source, java]
----
public interface UserRepository extends Repository<User, Long> {

  @QueryHints(value = { @QueryHint(name = ""name"", value = ""value"")},
              forCounting = false)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----
====
The preceding declaration would apply the configured `@QueryHint` for that actually query but omit applying it to the count query triggered to calculate the total number of pages.

[[jpa.entity-graph]]
=== Configuring Fetch- and LoadGraphs

The JPA 2.1 specification introduced support for specifying Fetch- and LoadGraphs that we also support with the `@EntityGraph` annotation, which lets you reference a `@NamedEntityGraph` definition. You can use that annotation on an entity to configure the fetch plan of the resulting query. The type (`Fetch` or `Load`) of the fetching can be configured by using the `type` attribute on the `@EntityGraph` annotation. See the JPA 2.1 Spec 3.7.4 for further reference.

The following example shows how to define a named entity graph on an entity:

.Defining a named entity graph on an entity.
====
[source, java]
----
@Entity
@NamedEntityGraph(name = ""GroupInfo.detail"",
  attributeNodes = @NamedAttributeNode(""members""))
public class GroupInfo {

  // default fetch mode is lazy.
  @ManyToMany
  List<GroupMember> members = new ArrayList<GroupMember>();

  …
}
----
====

The following example shows how to reference a named entity graph on a repository query method:

.Referencing a named entity graph definition on a repository query method.
====
[source, java]
----
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(value = ""GroupInfo.detail"", type = EntityGraphType.LOAD)
  GroupInfo getByGroupName(String name);

}
----
====

It is also possible to define ad hoc entity graphs by using `@EntityGraph`. The provided `attributePaths` are translated into the according `EntityGraph` without needing to explicitly add `@NamedEntityGraph` to your domain types, as shown in the following example:

.Using AD-HOC entity graph definition on an repository query method.
====
[source, java]
----
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(attributePaths = { ""members"" })
  GroupInfo getByGroupName(String name);

}
----
====

:repository-projections-trailing-dto-fragment: ../../../../spring-data-jpa/src/main/asciidoc/repository-projections-dto-limitations.adoc

include::{spring-data-commons-docs}/repository-projections.adoc[leveloffset=+2]

[[jpa.stored-procedures]]
== Stored Procedures
The JPA 2.1 specification introduced support for calling stored procedures by using the JPA criteria query API.
We Introduced the `@Procedure` annotation for declaring stored procedure metadata on a repository method.

The examples to follow use the following stored procedure:

.The definition of the `plus1inout` procedure in HSQL DB.
====
[source, sql]
----
/;
DROP procedure IF EXISTS plus1inout
/;
CREATE procedure plus1inout (IN arg int, OUT res int)
BEGIN ATOMIC
 set res = arg + 1;
END
/;
----
====

Metadata for stored procedures can be configured by using the `NamedStoredProcedureQuery` annotation on an entity type.

[[jpa.stored-procedure-entity-metadata]]
.StoredProcedure metadata definitions on an entity.
====
[source, java]
----
@Entity
@NamedStoredProcedureQuery(name = ""User.plus1"", procedureName = ""plus1inout"", parameters = {
  @StoredProcedureParameter(mode = ParameterMode.IN, name = ""arg"", type = Integer.class),
  @StoredProcedureParameter(mode = ParameterMode.OUT, name = ""res"", type = Integer.class) })
public class User {}
----
====

Note that `@NamedStoredProcedureQuery` has two different names for the stored procedure.
`name` is the name JPA uses. `procedureName` is the name the stored procedure has in the database.

You can reference stored procedures from a repository method in multiple ways.
The stored procedure to be called can either be defined directly by using the `value` or `procedureName` attribute of the `@Procedure` annotation.
This refers directly to the stored procedure in the database and ignores any configuration via `@NamedStoredProcedureQuery`.

Alternatively you may specify the `@NamedStoredProcedureQuery.name` attribute as the `@Procedure.name` attribute.
If neither `value`, `procedureName` nor `name` is configured, the name of the repository method is used as the `name` attribute.

The following example shows how to reference an explicitly mapped procedure:

[[jpa.stored-procedure-reference]]
.Referencing explicitly mapped procedure with name ""plus1inout"" in database.
====
[source, java]
----
@Procedure(""plus1inout"")
Integer explicitlyNamedPlus1inout(Integer arg);
----
====

The following example is equivalent to the previous one but uses the `procedureName` alias:

.Referencing implicitly mapped procedure with name ""plus1inout"" in database via `procedureName` alias.
====
[source, java]
----
@Procedure(procedureName = ""plus1inout"")
Integer callPlus1InOut(Integer arg);
----
====

The following is again equivalent to the previous two but using the method name instead of an explicite annotation attribute.

.Referencing implicitly mapped named stored procedure ""User.plus1"" in `EntityManager` by using the method name.
====
[source, java]
----
@Procedure
Integer plus1inout(@Param(""arg"") Integer arg);
----
====

The following example shows how to reference a stored procedure by referencing the `@NamedStoredProcedureQuery.name` attribute.

.Referencing explicitly mapped named stored procedure ""User.plus1IO"" in `EntityManager`.
====
[source, java]
----
@Procedure(name = ""User.plus1IO"")
Integer entityAnnotatedCustomNamedProcedurePlus1IO(@Param(""arg"") Integer arg);
----
====

If the stored procedure getting called has a single out parameter that parameter may be returned as the return value of the method.
If there are multiple out parameters specified in a `@NamedStoredProcedureQuery` annotation those can be returned as a `Map` with the key being the parameter name given in the `@NamedStoredProcedureQuery` annotation.


[[specifications]]
== Specifications

JPA 2 introduces a criteria API that you can use to build queries programmatically. By writing a `criteria`, you define the where clause of a query for a domain class. Taking another step back, these criteria can be regarded as a predicate over the entity that is described by the JPA criteria API constraints.

Spring Data JPA takes the concept of a specification from Eric Evans' book, ""`Domain Driven Design`"", following the same semantics and providing an API to define such specifications with the JPA criteria API. To support specifications, you can extend your repository interface with the `JpaSpecificationExecutor` interface, as follows:

[source, java]
----
public interface CustomerRepository extends CrudRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
 …
}
----

The additional interface has methods that let you run specifications in a variety of ways. For example, the `findAll` method returns all entities that match the specification, as shown in the following example:

[source, java]
----
List<T> findAll(Specification<T> spec);
----

The `Specification` interface is defined as follows:

[source, java]
----
public interface Specification<T> {
  Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder);
}
----

Specifications can easily be used to build an extensible set of predicates on top of an entity that then can be combined and used with `JpaRepository` without the need to declare a query (method) for every needed combination, as shown in the following example:

.Specifications for a Customer
====
[source, java]
----
public class CustomerSpecs {


  public static Specification<Customer> isLongTermCustomer() {
    return (root, query, builder) -> {
      LocalDate date = LocalDate.now().minusYears(2);
      return builder.lessThan(root.get(Customer_.createdAt), date);
    };
  }

  public static Specification<Customer> hasSalesOfMoreThan(MonetaryAmount value) {
    return (root, query, builder) -> {
      // build query here
    };
  }
}
----
====

The `Customer_` type is a metamodel type generated using the JPA Metamodel generator (see the link:$$https://docs.jboss.org/hibernate/jpamodelgen/1.0/reference/en-US/html_single/#whatisit$$[Hibernate implementation's documentation for an example]).
So the expression, `Customer_.createdAt`, assumes the `Customer` has a `createdAt` attribute of type `Date`.
Besides that, we have expressed some criteria on a business requirement abstraction level and created executable `Specifications`.
So a client might use a `Specification` as follows:

.Using a simple Specification
====
[source, java]
----
List<Customer> customers = customerRepository.findAll(isLongTermCustomer());
----
====

Why not create a query for this kind of data access? Using a single `Specification` does not gain a lot of benefit over a plain query declaration. The power of specifications really shines when you combine them to create new `Specification` objects. You can achieve this through the default methods of `Specification` we provide to build expressions similar to the following:

.Combined Specifications
====
[source, java]
----
MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
List<Customer> customers = customerRepository.findAll(
  isLongTermCustomer().or(hasSalesOfMoreThan(amount)));
----

`Specification` offers some ""`glue-code`"" default methods to chain and combine `Specification` instances. These methods let you extend your data access layer by creating new `Specification` implementations and combining them with already existing implementations.
====

include::{spring-data-commons-docs}/query-by-example.adoc[leveloffset=+1]
include::query-by-example.adoc[leveloffset=+1]

[[transactions]]
== Transactionality

By default, CRUD methods on repository instances inherited from link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/org/springframework/data/jpa/repository/support/SimpleJpaRepository.html$$[`SimpleJpaRepository`] are transactional.
For read operations, the transaction configuration `readOnly` flag is set to `true`.
All others are configured with a plain `@Transactional` so that default transaction configuration applies.
Repository methods that are backed by transactional repository fragments inherit the transactional attributes from the actual fragment method.

If you need to tweak transaction configuration for one of the methods declared in a repository, redeclare the method in your repository interface, as follows:

.Custom transaction configuration for CRUD
====
[source, java]
----
public interface UserRepository extends CrudRepository<User, Long> {

  @Override
  @Transactional(timeout = 10)
  public List<User> findAll();

  // Further query method declarations
}
----
Doing so causes the `findAll()` method to run with a timeout of 10 seconds and without the `readOnly` flag.
====

Another way to alter transactional behaviour is to use a facade or service implementation that (typically) covers more than one repository. Its purpose is to define transactional boundaries for non-CRUD operations. The following example shows how to use such a facade for more than one repository:

.Using a facade to define transactions for multiple repository calls
====
[source, java]
----
@Service
public class UserManagementImpl implements UserManagement {

  private final UserRepository userRepository;
  private final RoleRepository roleRepository;

  public UserManagementImpl(UserRepository userRepository,
    RoleRepository roleRepository) {
    this.userRepository = userRepository;
    this.roleRepository = roleRepository;
  }

  @Transactional
  public void addRoleToAllUsers(String roleName) {

    Role role = roleRepository.findByName(roleName);

    for (User user : userRepository.findAll()) {
      user.addRole(role);
      userRepository.save(user);
    }
  }
}
----
This example causes call to `addRoleToAllUsers(…)` to run inside a transaction (participating in an existing one or creating a new one if none are already running). The transaction configuration at the repositories is then neglected, as the outer transaction configuration determines the actual one used. Note that you must activate `<tx:annotation-driven />` or use `@EnableTransactionManagement` explicitly to get annotation-based configuration of facades to work.
This example assumes you use component scanning.

Note that the call to `save` is not strictly necessary from a JPA point of view, but should still be there in order to stay consistent to the repository abstraction offered by Spring Data.
====

[[transactional-query-methods]]
=== Transactional query methods

To let your query methods be transactional, use `@Transactional` at the repository interface you define, as shown in the following example:

.Using @Transactional at query methods
====
[source, java]
----
@Transactional(readOnly = true)
interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  @Modifying
  @Transactional
  @Query(""delete from User u where u.active = false"")
  void deleteInactiveUsers();
}
----
Typically, you want the `readOnly` flag to be set to `true`, as most of the query methods only read data. In contrast to that, `deleteInactiveUsers()` makes use of the `@Modifying` annotation and overrides the transaction configuration. Thus, the method runs with the `readOnly` flag set to `false`.
====

[NOTE]
====
You can use transactions for read-only queries and mark them as such by setting the `readOnly` flag. Doing so does not, however, act as a check that you do not trigger a manipulating query (although some databases reject `INSERT` and `UPDATE` statements inside a read-only transaction). The `readOnly` flag is instead propagated as a hint to the underlying JDBC driver for performance optimizations. Furthermore, Spring performs some optimizations on the underlying JPA provider. For example, when used with Hibernate, the flush mode is set to `NEVER` when you configure a transaction as `readOnly`, which causes Hibernate to skip dirty checks (a noticeable improvement on large object trees).
====

[[locking]]
== Locking
To specify the lock mode to be used, you can use the `@Lock` annotation on query methods, as shown in the following example:

.Defining lock metadata on query methods
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  // Plain query method
  @Lock(LockModeType.READ)
  List<User> findByLastname(String lastname);
}
----
====

This method declaration causes the query being triggered to be equipped with a `LockModeType` of `READ`. You can also define locking for CRUD methods by redeclaring them in your repository interface and adding the `@Lock` annotation, as shown in the following example:

.Defining lock metadata on CRUD methods
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  // Redeclaration of a CRUD method
  @Lock(LockModeType.READ)
  List<User> findAll();
}
----
====

:leveloffset: +1

include::{spring-data-commons-docs}/auditing.adoc[]

:leveloffset: -1

There is also a convenience base class, `AbstractAuditable`, which you can extend to avoid the need to manually implement the interface methods. Doing so increases the coupling of your domain classes to Spring Data, which might be something you want to avoid. Usually, the annotation-based way of defining auditing metadata is preferred as it is less invasive and more flexible.

[[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();
  }
}
----
",12189,False,2030.4011227419317,median
"// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#include <algorithm>
#include <cinttypes>
#include <cmath>
#include <cstdlib>
#include <iterator>
#include <limits>
#include <numeric>
#include <random>
#include <string>

// clang-format off
#ifdef ${BACKEND_NAME}_FLOAT_TOLERANCE_BITS
#define DEFAULT_FLOAT_TOLERANCE_BITS ${BACKEND_NAME}_FLOAT_TOLERANCE_BITS
#endif
// clang-format on

#include ""gtest/gtest.h""
#include ""ngraph/check.hpp""
#include ""ngraph/ngraph.hpp""
#include ""ngraph/opsets/opset4.hpp""
#include ""ngraph/op/util/attr_types.hpp""
#include ""util/all_close.hpp""
#include ""util/all_close_f.hpp""
#include ""util/engine/test_engines.hpp""
#include ""util/ndarray.hpp""
#include ""util/random.hpp""
#include ""util/test_case.hpp""
#include ""util/test_control.hpp""
#include ""util/test_tools.hpp""

NGRAPH_SUPPRESS_DEPRECATED_START

using namespace std;
using namespace ngraph;

static string s_manifest = ""${MANIFEST}"";

using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME});

NGRAPH_TEST(${BACKEND_NAME}, elu)
{
    auto A = make_shared<op::Parameter>(element::f32, Shape{3, 2});
    auto elu = make_shared<op::Elu>(A, 0.5f);
    auto function = make_shared<Function>(NodeVector{elu}, ParameterVector{A});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input(vector<float>{-2.f, 3.f, -2.f, 1.f, -1.f, 0.f});
    test_case.add_expected_output(
        vector<float>{-0.432332358f, 3.f, -0.432332358f, 1.f, -0.316060279f, 0.f});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, elu_negative_alpha)
{
    auto A = make_shared<op::Parameter>(element::f32, Shape{3, 2});
    auto elu = make_shared<op::Elu>(A, -1.f);
    auto function = make_shared<Function>(NodeVector{elu}, ParameterVector{A});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input(vector<float>{-2.f, 3.f, -2.f, 1.f, -1.f, 0.f});
    test_case.add_expected_output(
        vector<float>{0.864664717f, 3.f, 0.864664717f, 1.f, 0.632120559f, 0.f});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, prelu)
{
    Shape shape{3, 2};
    Shape rshape{3};
    auto A = make_shared<op::Parameter>(element::f32, shape);
    auto B = make_shared<op::Parameter>(element::f32, rshape);
    auto prelu = make_shared<op::PRelu>(A, B);
    auto f = make_shared<Function>(NodeVector{prelu}, ParameterVector{A, B});
    std::vector<float> a{-2, 3, -2, 1, -1, 0};
    std::vector<float> b{0, 0.5, 1};

    auto test_case = test::TestCase<TestEngine>(f);
    test_case.add_multiple_inputs<float>({a, b});
    test_case.add_expected_output<float>(vector<float>{0, 3, -1, 1, -1, 0});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, hardsigmoid)
{
    const Shape shape{2, 7};
    const float alpha_f = 0.125f;
    const float beta_f = 0.642f;
    const auto A = make_shared<op::Parameter>(element::f32, shape);
    const auto alpha = op::Constant::create<float>(A->get_element_type(), Shape{}, {alpha_f});
    const auto beta = op::Constant::create<float>(A->get_element_type(), Shape{}, {beta_f});
    auto hardsigmoid = make_shared<op::HardSigmoid>(A, alpha, beta);
    auto f = make_shared<Function>(NodeVector{hardsigmoid}, ParameterVector{A});
    vector<float> input{-1.f,
                        0.f,
                        1.f,
                        -100.f,
                        100.f,
                        -3.1234567f,
                        5.876543f,
                        7.13245364f,
                        numeric_limits<float>::max(),
                        numeric_limits<float>::lowest(),
                        numeric_limits<float>::min(),
                        numeric_limits<float>::infinity(),
                        numeric_limits<float>::min() / 16.f,
                        -numeric_limits<float>::min() / 16.f};

    // Prepare expected output data
    auto impl = [alpha_f, beta_f](float val) { return min(max(alpha_f * val + beta_f, 0.f), 1.f); };
    vector<float> expected_output;
    transform(begin(input), end(input), back_inserter(expected_output), impl);

    auto test_case = test::TestCase<TestEngine>(f);
    test_case.add_input<float>(input);
    test_case.add_expected_output<float>(expected_output);
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, prelu_shared_slope)
{
    Shape shape{3, 2};
    Shape rshape{};
    auto A = make_shared<op::Parameter>(element::f32, shape);
    auto B = make_shared<op::Parameter>(element::f32, rshape);
    auto prelu = make_shared<op::PRelu>(A, B);
    auto f = make_shared<Function>(NodeVector{prelu}, ParameterVector{A, B});
    std::vector<float> a{-2, 3, -2, 1, -1, 0};
    std::vector<float> b{0.5};

    auto test_case = test::TestCase<TestEngine>(f);
    test_case.add_multiple_inputs<float>({a, b});
    test_case.add_expected_output<float>(vector<float>{-1, 3, -1, 1, -0.5, 0});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, prelu_negative_slope)
{
    Shape shape{3, 2};
    Shape rshape{};
    auto A = make_shared<op::Parameter>(element::f32, shape);
    auto B = make_shared<op::Parameter>(element::f32, rshape);
    auto prelu = make_shared<op::PRelu>(A, B);
    auto f = make_shared<Function>(NodeVector{prelu}, ParameterVector{A, B});
    std::vector<float> a{-2, 3, -2, 1, -1, 0};
    std::vector<float> b{-0.5};

    auto test_case = test::TestCase<TestEngine>(f);
    test_case.add_multiple_inputs<float>({a, b});
    test_case.add_expected_output<float>(vector<float>{1, 3, 1, 1, 0.5, 0});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, space_to_depth_block_first)
{
    auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2, 4, 4});
    const auto mode = ngraph::op::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST;
    auto space_to_depth = make_shared<op::SpaceToDepth>(A, mode, 2);
    auto function = make_shared<Function>(NodeVector{space_to_depth}, ParameterVector{A});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input<float>({0.f,  1.f,  2.f,  3.f,  4.f,  5.f,  6.f,  7.f,  8.f,  9.f,  10.f,
                                11.f, 12.f, 13.f, 14.f, 15.f, 16.f, 17.f, 18.f, 19.f, 20.f, 21.f,
                                22.f, 23.f, 24.f, 25.f, 26.f, 27.f, 28.f, 29.f, 30.f, 31.f});
    test_case.add_expected_output<float>(Shape{1, 8, 2, 2},
                                         {
                                             0.f, 2.f, 8.f,  10.f, 16.f, 18.f, 24.f, 26.f,
                                             1.f, 3.f, 9.f,  11.f, 17.f, 19.f, 25.f, 27.f,
                                             4.f, 6.f, 12.f, 14.f, 20.f, 22.f, 28.f, 30.f,
                                             5.f, 7.f, 13.f, 15.f, 21.f, 23.f, 29.f, 31.f,
                                         });
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, space_to_depth_depth_first)
{
    auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2, 4, 4});
    const auto mode = ngraph::op::SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST;
    auto space_to_depth = make_shared<op::SpaceToDepth>(A, mode, 2);
    auto function = make_shared<Function>(NodeVector{space_to_depth}, ParameterVector{A});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input<float>({0.f,  16.f, 2.f,  18.f, 1.f,  17.f, 3.f,  19.f, 8.f,  24.f, 10.f,
                                26.f, 9.f,  25.f, 11.f, 27.f, 4.f,  20.f, 6.f,  22.f, 5.f,  21.f,
                                7.f,  23.f, 12.f, 28.f, 14.f, 30.f, 13.f, 29.f, 15.f, 31.f});
    test_case.add_expected_output<float>(
        Shape{1, 8, 2, 2}, {0.f,  2.f,  8.f,  10.f, 16.f, 18.f, 24.f, 26.f, 1.f,  3.f,  9.f,
                            11.f, 17.f, 19.f, 25.f, 27.f, 4.f,  6.f,  12.f, 14.f, 20.f, 22.f,
                            28.f, 30.f, 5.f,  7.f,  13.f, 15.f, 21.f, 23.f, 29.f, 31.f});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, depth_to_space_block_first)
{
    auto A = make_shared<op::Parameter>(element::f32, Shape{1, 8, 2, 2});
    auto depth_to_space =
        make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
    auto function = make_shared<Function>(NodeVector{depth_to_space}, ParameterVector{A});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input<float>({
        0.f, 2.f, 8.f,  10.f, 16.f, 18.f, 24.f, 26.f, 1.f, 3.f, 9.f,  11.f, 17.f, 19.f, 25.f, 27.f,
        4.f, 6.f, 12.f, 14.f, 20.f, 22.f, 28.f, 30.f, 5.f, 7.f, 13.f, 15.f, 21.f, 23.f, 29.f, 31.f,
    });
    test_case.add_expected_output<float>(
        Shape{1, 2, 4, 4}, {0.f,  1.f,  2.f,  3.f,  4.f,  5.f,  6.f,  7.f,  8.f,  9.f,  10.f,
                            11.f, 12.f, 13.f, 14.f, 15.f, 16.f, 17.f, 18.f, 19.f, 20.f, 21.f,
                            22.f, 23.f, 24.f, 25.f, 26.f, 27.f, 28.f, 29.f, 30.f, 31.f});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, depth_to_space_depth_first)
{
    auto A = make_shared<op::Parameter>(element::f32, Shape{1, 8, 2, 2});
    auto depth_to_space =
        make_shared<op::DepthToSpace>(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
    auto function = make_shared<Function>(NodeVector{depth_to_space}, ParameterVector{A});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input<float>({
        0.f, 2.f, 8.f,  10.f, 16.f, 18.f, 24.f, 26.f, 1.f, 3.f, 9.f,  11.f, 17.f, 19.f, 25.f, 27.f,
        4.f, 6.f, 12.f, 14.f, 20.f, 22.f, 28.f, 30.f, 5.f, 7.f, 13.f, 15.f, 21.f, 23.f, 29.f, 31.f,
    });
    test_case.add_expected_output<float>(
        Shape{1, 2, 4, 4}, {0.f,  16.f, 2.f,  18.f, 1.f,  17.f, 3.f,  19.f, 8.f,  24.f, 10.f,
                            26.f, 9.f,  25.f, 11.f, 27.f, 4.f,  20.f, 6.f,  22.f, 5.f,  21.f,
                            7.f,  23.f, 12.f, 28.f, 14.f, 30.f, 13.f, 29.f, 15.f, 31.f});
    test_case.run();
}
// TODO: Issue: 37521
NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_chw_4d)
{
    Shape data_shape{1, 2, 3, 4};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{3}, vector<int64_t>{1, 2, 3});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape, {0.01428571f, 0.02857143f, 0.04285714f, 0.05714286f, 0.07142857f, 0.08571429f,
                     0.1f,        0.11428571f, 0.12857144f, 0.14285715f, 0.15714286f, 0.17142858f,
                     0.18571429f, 0.2f,        0.21428572f, 0.22857143f, 0.24285714f, 0.25714287f,
                     0.27142859f, 0.2857143f,  0.30000001f, 0.31428573f, 0.32857144f, 0.34285715f});

    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_empty_axes_input)
{
    Shape data_shape{1, 2, 3, 4};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{0}, vector<int64_t>{});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape,
        vector<float>{0.01428571, 0.02857143, 0.04285714, 0.05714286, 0.07142857, 0.08571429,
                      0.1,        0.11428571, 0.12857144, 0.14285715, 0.15714286, 0.17142858,

                      0.18571429, 0.2,        0.21428572, 0.22857143, 0.24285714, 0.25714287,
                      0.27142859, 0.2857143,  0.3,        0.31428573, 0.32857144, 0.34285715});
    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_h_4d)
{
    Shape data_shape{1, 2, 3, 4};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{1});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape, {0.0766965f,  0.14142136f, 0.19611613f, 0.24253564f, 0.28216633f, 0.31622776f,
                     0.34570536f, 0.37139067f, 0.39391932f, 0.41380295f, 0.43145549f, 0.44721359f,
                     0.99705452f, 0.98994946f, 0.98058069f, 0.97014254f, 0.95936549f, 0.94868332f,
                     0.93834311f, 0.92847669f, 0.91914505f, 0.91036648f, 0.90213418f, 0.89442718f});
    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_1axis_5d)
{
    Shape data_shape{1, 2, 2, 2, 3};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{1}, vector<int64_t>{1});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape, {0.0766965f,  0.14142136f, 0.19611613f, 0.24253564f, 0.28216633f, 0.31622776f,
                     0.34570536f, 0.37139067f, 0.39391932f, 0.41380295f, 0.43145549f, 0.44721359f,
                     0.99705452f, 0.98994946f, 0.98058069f, 0.97014254f, 0.95936549f, 0.94868332f,
                     0.93834311f, 0.92847669f, 0.91914505f, 0.91036648f, 0.90213418f, 0.89442718f});
    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_123axes_5d)
{
    Shape data_shape{1, 2, 2, 2, 3};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{3}, vector<int64_t>{1, 2, 3});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape, {0.02638899f, 0.04956816f, 0.070014f,   0.10555596f, 0.1239204f,  0.140028f,
                     0.18472293f, 0.19827265f, 0.210042f,   0.26388991f, 0.27262488f, 0.280056f,
                     0.34305686f, 0.34697714f, 0.35007f,    0.42222384f, 0.42132938f, 0.420084f,
                     0.50139081f, 0.49568161f, 0.49009803f, 0.58055776f, 0.57003385f, 0.560112f});
    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_c_2x2_shape)
{
    Shape data_shape{2, 2};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{}, vector<int64_t>{1});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(data_shape,
                                         {0.44721353f, 0.89442706f, 0.60000002f, 0.80000001f});

    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_c_2x4_shape)
{
    Shape data_shape{2, 4};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{}, vector<int64_t>{1});
    float eps{1e-6f};
    auto eps_mode = op::EpsMode::ADD;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(data_shape,
                                         {0.18257418f,
                                          0.36514837f,
                                          0.54772252f,
                                          0.73029673f,
                                          0.37904903f,
                                          0.45485884f,
                                          0.53066862f,
                                          0.60647845f});

    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_normalize_across_chw_4d_max_bias)
{
    Shape data_shape{1, 2, 3, 4};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto axes = make_shared<op::Constant>(element::i64, Shape{3}, vector<int64_t>{1, 2, 3});
    float eps{5000};
    auto eps_mode = op::EpsMode::MAX;

    auto normalize = make_shared<op::NormalizeL2>(data, axes, eps, eps_mode);
    auto function = make_shared<Function>(NodeVector{normalize}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape, {0.01414214f, 0.02828427f, 0.04242641f, 0.05656854f, 0.07071068f, 0.08485281f,
                     0.09899495f, 0.11313709f, 0.12727922f, 0.14142136f, 0.15556349f, 0.16970563f,
                     0.18384777f, 0.1979899f,  0.21213204f, 0.22627418f, 0.2404163f,  0.25455844f,
                     0.26870057f, 0.28284273f, 0.29698485f, 0.31112698f, 0.32526913f, 0.33941126f});

    test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 1);
}

NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_normalization)
{
    Shape data_shape{1, 2, 5};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);

    auto mvn_func = make_shared<op::MVN>(data, true, false);
    auto function = make_shared<Function>(NodeVector{mvn_func}, ParameterVector{data});
    auto test_case = test::TestCase<TestEngine>(function);
    // data
    vector<float> data_vector(shape_size(data_shape));
    iota(begin(data_vector), end(data_vector), 0);
    test_case.add_input<float>(data_vector);

    // expected result
    test_case.add_expected_output<float>(
        data_shape, vector<float>{-4.5, -3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5, 4.5});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_normalization_split_channels)
{
    Shape data_shape{1, 2, 5, 1};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);

    auto mvn_func = make_shared<op::MVN>(data, false, false);
    auto function = make_shared<Function>(NodeVector{mvn_func}, ParameterVector{data});
    auto test_case = test::TestCase<TestEngine>(function);
    // data
    vector<float> data_vector(shape_size(data_shape));
    iota(begin(data_vector), end(data_vector), 0);
    test_case.add_input<float>(data_vector);

    // expected result
    test_case.add_expected_output<float>({1, 2, 5, 1},
                                         vector<float>{-2, -1, 0, 1, 2, -2, -1, 0, 1, 2});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_variance_normalization)
{
    Shape data_shape{1, 2, 5};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);

    auto mvn_func = make_shared<op::MVN>(data);
    auto function = make_shared<Function>(NodeVector{mvn_func}, ParameterVector{data});
    auto test_case = test::TestCase<TestEngine>(function);
    // data
    vector<float> data_vector(shape_size(data_shape));
    iota(begin(data_vector), end(data_vector), 0);
    test_case.add_input<float>(data_vector);

    // expected result
    test_case.add_expected_output<float>(data_shape,
                                         vector<float>{-1.566698903055826,
                                                       -1.2185435912656424,
                                                       -0.87038827947545883,
                                                       -0.52223296768527527,
                                                       -0.17407765589509178,
                                                       0.17407765589509178,
                                                       0.52223296768527527,
                                                       0.87038827947545883,
                                                       1.2185435912656424,
                                                       1.566698903055826});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_variance_normalization_split_channels)
{
    Shape data_shape{1, 2, 5};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);

    auto mvn_func = make_shared<op::MVN>(data, false);
    auto function = make_shared<Function>(NodeVector{mvn_func}, ParameterVector{data});
    auto test_case = test::TestCase<TestEngine>(function);
    // data
    vector<float> data_vector(shape_size(data_shape));
    iota(begin(data_vector), end(data_vector), 0);
    test_case.add_input<float>(data_vector);

    // expected result
    test_case.add_expected_output<float>(data_shape,
                                         vector<float>{-1.4142135613730948,
                                                       -0.70710678068654742,
                                                       0.000000000000000,
                                                       0.70710678068654742,
                                                       1.4142135613730948,
                                                       -1.4142135613730948,
                                                       -0.70710678068654742,
                                                       0.000000000000000,
                                                       0.70710678068654742,
                                                       1.4142135613730948});

    test_case.run();
}
NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_variance_normalization_shared_across_channel_batch_size_2)
{
    Shape data_shape{2, 2, 5};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);

    auto mvn_func = make_shared<op::MVN>(data, true);
    auto function = make_shared<Function>(NodeVector{mvn_func}, ParameterVector{data});
    auto test_case = test::TestCase<TestEngine>(function);
    // data
    vector<float> data_vector(shape_size(data_shape));
    iota(begin(data_vector), end(data_vector), 0);
    test_case.add_input<float>(data_vector);

    // expected result
    test_case.add_expected_output<float>(
        data_shape,
        {-1.5666989f, -1.2185436f, -0.8703883f, -0.5222329f, -0.1740777f, 0.1740777f,  0.5222329f,
         0.8703883f,  1.2185436f,  1.5666989f,  -1.5666989f, -1.2185436f, -0.8703883f, -0.5222329f,
         -0.1740777f, 0.1740777f,  0.5222329f,  0.8703883f,  1.2185436f,  1.5666989f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, mvn_mean_variance_normalization_not_shared_across_channel_batch_size_2)
{
    Shape data_shape{2, 2, 5};
    auto data = make_shared<op::Parameter>(element::f32, data_shape);

    auto mvn_func = make_shared<op::MVN>(data, false);
    auto function = make_shared<Function>(NodeVector{mvn_func}, ParameterVector{data});
    auto test_case = test::TestCase<TestEngine>(function);
    // data
    vector<float> data_vector(shape_size(data_shape));
    iota(begin(data_vector), end(data_vector), 0);
    test_case.add_input<float>(data_vector);

    // expected result
    test_case.add_expected_output<float>(
        data_shape,
        {-1.4142135f, -0.7071068f, 0.0000000f,  0.7071068f,  1.4142135f,  -1.4142135f, -0.7071068f,
         0.0000000f,  0.7071068f,  1.4142135f,  -1.4142135f, -0.7071068f, 0.0000000f,  0.7071068f,
         1.4142135f,  -1.4142135f, -0.7071068f, 0.0000000f,  0.7071068f,  1.4142135f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, grn_4d)
{
    const Shape data_shape{1, 2, 3, 4};
    const auto data = make_shared<op::Parameter>(element::f32, data_shape);
    float bias{1e-6f};

    const auto grn = make_shared<op::GRN>(data, bias);
    const auto function = make_shared<Function>(NodeVector{grn}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(
        data_shape, {0.0766965f,  0.14142136f, 0.19611613f, 0.24253564f, 0.28216633f, 0.31622776f,
                     0.34570536f, 0.37139067f, 0.39391932f, 0.41380295f, 0.4314555f,  0.4472136f,
                     0.9970545f,  0.98994946f, 0.9805807f,  0.97014254f, 0.9593655f,  0.9486833f,
                     0.9383431f,  0.9284767f,  0.91914505f, 0.9103665f,  0.9021342f,  0.8944272f});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_grn_2d_with_bias)
{
    const Shape data_shape{3, 4};
    const auto data = make_shared<op::Parameter>(element::f32, data_shape);
    float bias{2.25f};

    const auto grn = make_shared<op::GRN>(data, bias);
    const auto function = make_shared<Function>(NodeVector{grn}, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    vector<float> input_data(shape_size(data_shape));
    iota(begin(input_data), end(input_data), 1);

    test_case.add_input<float>(input_data);

    test_case.add_expected_output<float>(data_shape,
                                         {0.5547002f,
                                          0.8f,
                                          0.8944272f,
                                          0.9363292f,
                                          0.95782626f,
                                          0.9701425f,
                                          0.9778024f,
                                          0.98287225f,
                                          0.9863939f,
                                          0.9889363f,
                                          0.9908301f,
                                          0.99227786f});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, unsqueeze)
{
    auto data_node = make_shared<op::Parameter>(element::f32, Shape{4, 2});
    auto axes_node =
        make_shared<ngraph::op::Constant>(element::i64, Shape{2}, vector<int64_t>{1, 2});
    auto squeeze = make_shared<op::v0::Unsqueeze>(data_node, axes_node);

    auto function = make_shared<Function>(NodeVector{squeeze}, ParameterVector{data_node});
    auto test_case = test::TestCase<TestEngine>(function);

    auto data = vector<float>{1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
    test_case.add_input(data);
    test_case.add_expected_output<float>(Shape{4, 1, 1, 2}, data);
}

NGRAPH_TEST(${BACKEND_NAME}, shuffle_channels_simple)
{
    const auto data = make_shared<op::Parameter>(element::i32, Shape{1, 15, 2, 2});
    auto tested_op = make_shared<op::ShuffleChannels>(data, 1, 5);
    auto function = make_shared<Function>(tested_op, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    std::vector<int32_t> input_data(60);
    std::iota(std::begin(input_data), std::end(input_data), 0);
    test_case.add_input(input_data);

    test_case.add_expected_output<int32_t>(
        Shape{1, 15, 2, 2},
        {0, 1, 2,  3,  12, 13, 14, 15, 24, 25, 26, 27, 36, 37, 38, 39, 48, 49, 50, 51,
         4, 5, 6,  7,  16, 17, 18, 19, 28, 29, 30, 31, 40, 41, 42, 43, 52, 53, 54, 55,
         8, 9, 10, 11, 20, 21, 22, 23, 32, 33, 34, 35, 44, 45, 46, 47, 56, 57, 58, 59});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, shuffle_channels_negative_axis)
{
    // in this test the output is the same as in shuffle_channels_simple but
    // the axis value is negative and the C(channels) value is in a different dimension(0) of the
    // shape
    const auto data = make_shared<op::Parameter>(element::i32, Shape{15, 2, 1, 2});
    auto tested_op = make_shared<op::ShuffleChannels>(data, -4, 5);
    auto function = make_shared<Function>(tested_op, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    std::vector<int32_t> input_data(60);
    std::iota(std::begin(input_data), std::end(input_data), 0);
    test_case.add_input(input_data);

    test_case.add_expected_output<int32_t>(
        Shape{15, 2, 1, 2},
        {0, 1, 2,  3,  12, 13, 14, 15, 24, 25, 26, 27, 36, 37, 38, 39, 48, 49, 50, 51,
         4, 5, 6,  7,  16, 17, 18, 19, 28, 29, 30, 31, 40, 41, 42, 43, 52, 53, 54, 55,
         8, 9, 10, 11, 20, 21, 22, 23, 32, 33, 34, 35, 44, 45, 46, 47, 56, 57, 58, 59});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, shuffle_channels_float)
{
    const auto data = make_shared<op::Parameter>(element::f32, Shape{6, 1, 1, 1});
    auto tested_op = make_shared<op::ShuffleChannels>(data, 0, 2);
    auto function = make_shared<Function>(tested_op, ParameterVector{data});

    auto test_case = test::TestCase<TestEngine>(function);

    test_case.add_input<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f});

    test_case.add_expected_output<float>(Shape{6, 1, 1, 1}, {0.0f, 3.0f, 1.0f, 4.0f, 2.0f, 5.0f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, squeeze)
{
    const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1, 4, 1, 1, 2});
    const auto axes_node =
        make_shared<ngraph::op::Constant>(element::i64, Shape{2}, vector<int64_t>{0, 2});
    const auto squeeze = make_shared<op::Squeeze>(data_node, axes_node);

    const auto function = make_shared<Function>(NodeVector{squeeze}, ParameterVector{data_node});
    auto test_case = test::TestCase<TestEngine>(function);

    const auto data = vector<float>{1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
    test_case.add_input(data);
    test_case.add_expected_output<float>(Shape{4, 1, 2}, data);
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, squeeze_default_axes)
{
    const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1, 4, 1, 1, 2});
    const auto axes_node =
        make_shared<ngraph::op::Constant>(element::i64, Shape{0}, vector<int64_t>{});
    const auto squeeze = make_shared<op::Squeeze>(data_node, axes_node);

    const auto function = make_shared<Function>(NodeVector{squeeze}, ParameterVector{data_node});
    auto test_case = test::TestCase<TestEngine>(function);

    const auto data = vector<float>{1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
    test_case.add_input(data);
    test_case.add_expected_output<float>(Shape{4, 2}, data);
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, squeeze_dynamic)
{
    const auto data_param = make_shared<op::Parameter>(element::f32, Shape{1, 4, 1, 1, 2});
    const auto axes_param = make_shared<op::Parameter>(element::i64, Shape{2});

    const auto squeeze = make_shared<op::Squeeze>(data_param, axes_param);

    const auto function = make_shared<Function>(NodeVector{squeeze}, ParameterVector{data_param, axes_param});
    auto test_case = test::TestCase<TestEngine>(function);

    const auto data = vector<float>{1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
    test_case.add_input(data);
    test_case.add_input(vector<int64_t>{0, 2});
    test_case.add_expected_output<float>(Shape{4, 1, 2}, data);
    test_case.run();
}

// TODO: Issue: 37534
NGRAPH_TEST(${BACKEND_NAME}, DISABLED_squared_difference)
{
    const auto x1 = make_shared<op::Parameter>(element::f32, Shape{2, 2});
    const auto x2 = make_shared<op::Parameter>(element::f32, Shape{2, 2});

    auto tested_op = make_shared<op::SquaredDifference>(x1, x2);
    auto function = make_shared<Function>(tested_op, ParameterVector{x1, x2});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input<float>({1.0, 16.0, 0.0, 1.234567});
    test_case.add_input<float>({1.0, 8.0, -3.0, 3.456789});

    test_case.add_expected_output<float>(Shape{2, 2}, {0.0, 64.0, 9.0, 4.938270617284});
    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_squared_difference_broadcast)
{
    const auto x1 = make_shared<op::Parameter>(element::i32, Shape{2, 2});
    const auto x2 = make_shared<op::Parameter>(element::i32, Shape{});

    auto tested_op = make_shared<op::SquaredDifference>(x1, x2);
    auto function = make_shared<Function>(tested_op, ParameterVector{x1, x2});

    auto test_case = test::TestCase<TestEngine>(function);
    test_case.add_input<int32_t>({1, 1, 1, 1});
    test_case.add_input<int32_t>({1});

    test_case.add_expected_output<int32_t>(Shape{2, 2}, {0, 0, 0, 0});
    test_case.run();
}

// TODO: Issue: 37511
NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize)
{
    const Shape data_shape{1, 2, 3, 4};
    const size_t levels = 4;
    const auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto input_low = make_shared<op::Parameter>(element::f32, Shape{});
    const auto input_high = make_shared<op::Parameter>(element::f32, Shape{});
    const auto output_low = make_shared<op::Parameter>(element::f32, Shape{});
    const auto output_high = make_shared<op::Parameter>(element::f32, Shape{});

    const auto quantize =
        make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels);
    const auto function = make_shared<Function>(
        NodeVector{quantize},
        ParameterVector{data, input_low, input_high, output_low, output_high});
    auto test_case = test::TestCase<TestEngine>(function);

    const size_t n_elements = shape_size(data_shape);
    vector<float> input_data(n_elements);
    iota(begin(input_data), end(input_data), 0);

    test_case.add_input<float>(input_data);
    // input_low
    test_case.add_input<float>({0.0f});
    // input_high
    test_case.add_input<float>({23.f});
    // output_low
    test_case.add_input<float>({2.f});
    // output_high
    test_case.add_input<float>({16.f});

    // expected result
    test_case.add_expected_output<float>(
        data_shape,
        vector<float>{2.f,          2.f,          2.f,          2.f,          6.6666669f,
                      6.6666669f,   6.6666669f,   6.6666669f,   6.6666669f,   6.6666669f,
                      6.6666669f,   6.6666669f,   11.33333301f, 11.33333301f, 11.33333301f,
                      11.33333301f, 11.33333301f, 11.33333301f, 11.33333301f, 11.33333301f,
                      16.f,         16.f,         16.f,         16.f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize_with_clip)
{
    const Shape data_shape{1, 2, 3, 4};
    const size_t levels = 5;
    const auto data = make_shared<op::Parameter>(element::f32, data_shape);
    const auto input_low = make_shared<op::Parameter>(element::f32, Shape{});
    const auto input_high = make_shared<op::Parameter>(element::f32, Shape{});
    const auto output_low = make_shared<op::Parameter>(element::f32, Shape{});
    const auto output_high = make_shared<op::Parameter>(element::f32, Shape{});

    const auto quantize =
        make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels);
    const auto function = make_shared<Function>(
        NodeVector{quantize},
        ParameterVector{data, input_low, input_high, output_low, output_high});
    auto test_case = test::TestCase<TestEngine>(function);

    const size_t n_elements = shape_size(data_shape);
    vector<float> input_data(n_elements);
    iota(begin(input_data), end(input_data), 0);

    test_case.add_input<float>(input_data);
    // input_low
    test_case.add_input<float>({3.f});
    // input_high
    test_case.add_input<float>({17.f});
    // output_low
    test_case.add_input<float>({2.f});
    // output_high
    test_case.add_input<float>({16.f});

    // expected result
    test_case.add_expected_output<float>(
        data_shape,
        vector<float>{2.f,   2.f,   2.f,   2.f,   2.f,  5.5f, 5.5f, 5.5f, 5.5f, 9.f,  9.f,  9.f,
                      12.5f, 12.5f, 12.5f, 12.5f, 16.f, 16.f, 16.f, 16.f, 16.f, 16.f, 16.f, 16.f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize_with_clip_across_channels)
{
    Shape data_shape{1, 2, 5, 5};
    size_t levels = 5;
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    auto input_low = make_shared<op::Parameter>(element::f32, Shape{2, 1, 1});
    auto input_high = make_shared<op::Parameter>(element::f32, Shape{2, 1, 1});
    auto output_low = make_shared<op::Parameter>(element::f32, Shape{2, 1, 1});
    auto output_high = make_shared<op::Parameter>(element::f32, Shape{2, 1, 1});

    auto quantize =
        make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels);
    auto function = make_shared<Function>(
        NodeVector{quantize},
        ParameterVector{data, input_low, input_high, output_low, output_high});
    auto test_case = test::TestCase<TestEngine>(function);

    size_t n_elements = shape_size(data_shape);
    vector<float> input_data(n_elements);
    iota(begin(input_data), end(input_data), 0);

    test_case.add_input<float>(input_data);
    // input_low
    test_case.add_input<float>(vector<float>{5.f, 30.f});
    // input_high
    test_case.add_input<float>(vector<float>{10.f, 40.f});
    // output_low
    test_case.add_input<float>(vector<float>{0.f, 50.f});
    // output_high
    test_case.add_input<float>(vector<float>{20.f, 70.f});

    // expected result
    test_case.add_expected_output<float>(
        data_shape,
        vector<float>{0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  5.0f,  10.0f, 10.0f, 15.0f,
                      20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f,
                      20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f,
                      50.0f, 50.0f, 55.0f, 55.0f, 60.0f, 60.0f, 60.0f, 65.0f, 65.0f, 70.0f,
                      70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, DISABLED_fake_quantize_pdpd)
{
    Shape data_shape{1, 2, 5, 5};
    size_t levels = 5;
    auto data = make_shared<op::Parameter>(element::f32, data_shape);
    auto input_low = make_shared<op::Parameter>(element::f32, Shape{2});
    auto input_high = make_shared<op::Parameter>(element::f32, Shape{2});
    auto output_low = make_shared<op::Parameter>(element::f32, Shape{2});
    auto output_high = make_shared<op::Parameter>(element::f32, Shape{2});

    auto quantize =
        make_shared<op::FakeQuantize>(data,
                                      input_low,
                                      input_high,
                                      output_low,
                                      output_high,
                                      levels,
                                      op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD, 1));
    auto function = make_shared<Function>(
        NodeVector{quantize},
        ParameterVector{data, input_low, input_high, output_low, output_high});
    auto test_case = test::TestCase<TestEngine>(function);

    size_t n_elements = shape_size(data_shape);
    vector<float> input_data(n_elements);
    iota(begin(input_data), end(input_data), 0);

    test_case.add_input<float>(input_data);
    // input_low
    test_case.add_input<float>(vector<float>{5.f, 30.f});
    // input_high
    test_case.add_input<float>(vector<float>{10.f, 40.f});
    // output_low
    test_case.add_input<float>(vector<float>{0.f, 50.f});
    // output_high
    test_case.add_input<float>(vector<float>{20.f, 70.f});

    // expected result
    test_case.add_expected_output<float>(
        data_shape,
        vector<float>{0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  5.0f,  10.0f, 10.0f, 15.0f,
                      20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f,
                      20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f,
                      50.0f, 50.0f, 55.0f, 55.0f, 60.0f, 60.0f, 60.0f, 65.0f, 65.0f, 70.0f,
                      70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f, 70.0f});

    test_case.run();
}

NGRAPH_TEST(${BACKEND_NAME}, depth_to_space_space_to_depth_block_first)
{
    auto backend = runtime::Backend::create(""${BACKEND_NAME}"");
    Shape dts_input_shape{2, 32, 2, 4, 2, 4};
    size_t block_size = 2;

    auto dts_input = make_shared<op::Parameter>(element::f32, dts_input_shape);
    auto depth_to_space = make_shared<op::DepthToSpace>(
        dts_input, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, block_size);
    auto dts_func = make_shared<Function>(NodeVector{depth_to_space}, ParameterVector{dts_input});

    auto dts_input_tensor = backend->create_tensor(element::f32, dts_input_shape);
    const auto data_size = shape_size(dts_input_shape);
    vector<float> data(data_size);
    std::iota(data.begin(), data.end(), 0);
    copy_data(dts_input_tensor, data);
    const auto dts_output_shape = depth_to_space->get_output_shape(0);
    auto dts_output_tensor = backend->create_tensor(element::f32, dts_output_shape);
    auto handle = backend->compile(dts_func);
    handle->call_with_validate({dts_output_tensor}, {dts_input_tensor});
    auto dts_result = read_vector<float>(dts_output_tensor);

    // use depth_to_space output as space_to_depth input
    auto std_input = make_shared<op::Parameter>(element::f32, dts_output_shape);
    auto space_to_depth = make_shared<op::SpaceToDepth>(
        std_input, op::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, block_size);
    auto std_func = make_shared<Function>(NodeVector{space_to_depth}, ParameterVector{std_input});

    auto std_input_tensor = backend->create_tensor(element::f32, dts_output_shape);
    copy_data(std_input_tensor, dts_result);
    auto std_output_tensor = backend->create_tensor(element::f32, dts_input_shape);
    handle = backend->compile(std_func);
    handle->call_with_validate({std_output_tensor}, {std_input_tensor});
    auto std_result = read_vector<float>(std_output_tensor);

    // expected output of space_to_depth is input of depth_to_space
    ASSERT_EQ(dts_input_shape, space_to_depth->get_output_shape(0));
    EXPECT_TRUE(test::all_close_f(std_result, data, data_size));
}

NGRAPH_TEST(${BACKEND_NAME}, depth_to_space_space_to_depth_depth_first)
{
    auto backend = runtime::Backend::create(""${BACKEND_NAME}"");
    Shape dts_input_shape{2, 32, 2, 4, 2, 4};
    size_t block_size = 2;

    auto dts_input = make_shared<op::Parameter>(element::f32, dts_input_shape);
    auto depth_to_space = make_shared<op::DepthToSpace>(
        dts_input, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, block_size);
    auto dts_func = make_shared<Function>(NodeVector{depth_to_space}, ParameterVector{dts_input});

    auto dts_input_tensor = backend->create_tensor(element::f32, dts_input_shape);
    const auto data_size = shape_size(dts_input_shape);
    vector<float> data(data_size);
    std::iota(data.begin(), data.end(), 0);
    copy_data(dts_input_tensor, data);
    const auto dts_output_shape = depth_to_space->get_output_shape(0);
    auto dts_output_tensor = backend->create_tensor(element::f32, dts_output_shape);
    auto handle = backend->compile(dts_func);
    handle->call_with_validate({dts_output_tensor}, {dts_input_tensor});
    auto dts_result = read_vector<float>(dts_output_tensor);

    // use depth_to_space output as space_to_depth input
    auto std_input = make_shared<op::Parameter>(element::f32, dts_output_shape);
    auto space_to_depth = make_shared<op::SpaceToDepth>(
        std_input, op::SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST, block_size);
    auto std_func = make_shared<Function>(NodeVector{space_to_depth}, ParameterVector{std_input});

    auto std_input_tensor = backend->create_tensor(element::f32, dts_output_shape);
    copy_data(std_input_tensor, dts_result);
    auto std_output_tensor = backend->create_tensor(element::f32, dts_input_shape);
    handle = backend->compile(std_func);
    handle->call_with_validate({std_output_tensor}, {std_input_tensor});
    auto std_result = read_vector<float>(std_output_tensor);

    // expected output of space_to_depth is input of depth_to_space
    ASSERT_EQ(dts_input_shape, space_to_depth->get_output_shape(0));
    EXPECT_TRUE(test::all_close_f(std_result, data, data_size));
}
",16338,True,3640.4646163517627,median
"//
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2021
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include ""td/telegram/WebPagesManager.h""

#include ""td/telegram/AnimationsManager.h""
#include ""td/telegram/AudiosManager.h""
#include ""td/telegram/AuthManager.h""
#include ""td/telegram/Document.h""
#include ""td/telegram/Document.hpp""
#include ""td/telegram/DocumentsManager.h""
#include ""td/telegram/FileReferenceManager.h""
#include ""td/telegram/files/FileId.h""
#include ""td/telegram/files/FileManager.h""
#include ""td/telegram/files/FileSourceId.h""
#include ""td/telegram/Global.h""
#include ""td/telegram/logevent/LogEvent.h""
#include ""td/telegram/MessageEntity.h""
#include ""td/telegram/MessagesManager.h""
#include ""td/telegram/Photo.h""
#include ""td/telegram/secret_api.h""
#include ""td/telegram/StickersManager.h""
#include ""td/telegram/Td.h""
#include ""td/telegram/TdDb.h""
#include ""td/telegram/TdParameters.h""
#include ""td/telegram/VideoNotesManager.h""
#include ""td/telegram/VideosManager.h""
#include ""td/telegram/VoiceNotesManager.h""
#include ""td/telegram/WebPageBlock.h""

#include ""td/db/binlog/BinlogEvent.h""
#include ""td/db/binlog/BinlogHelper.h""
#include ""td/db/SqliteKeyValue.h""
#include ""td/db/SqliteKeyValueAsync.h""

#include ""td/utils/algorithm.h""
#include ""td/utils/buffer.h""
#include ""td/utils/common.h""
#include ""td/utils/format.h""
#include ""td/utils/HttpUrl.h""
#include ""td/utils/logging.h""
#include ""td/utils/misc.h""
#include ""td/utils/Slice.h""
#include ""td/utils/SliceBuilder.h""
#include ""td/utils/StringBuilder.h""
#include ""td/utils/tl_helpers.h""
#include ""td/utils/utf8.h""

#include <limits>

namespace td {

class GetWebPagePreviewQuery final : public Td::ResultHandler {
  Promise<Unit> promise_;
  int64 request_id_;
  string url_;

 public:
  explicit GetWebPagePreviewQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
  }

  void send(const string &text, vector<tl_object_ptr<telegram_api::MessageEntity>> &&entities, int64 request_id,
            string url) {
    request_id_ = request_id;
    url_ = std::move(url);

    int32 flags = 0;
    if (!entities.empty()) {
      flags |= telegram_api::messages_getWebPagePreview::ENTITIES_MASK;
    }

    send_query(
        G()->net_query_creator().create(telegram_api::messages_getWebPagePreview(flags, text, std::move(entities))));
  }

  void on_result(BufferSlice packet) final {
    auto result_ptr = fetch_result<telegram_api::messages_getWebPagePreview>(packet);
    if (result_ptr.is_error()) {
      return on_error(result_ptr.move_as_error());
    }

    auto ptr = result_ptr.move_as_ok();
    LOG(INFO) << ""Receive result for GetWebPagePreviewQuery: "" << to_string(ptr);
    td_->web_pages_manager_->on_get_web_page_preview_success(request_id_, url_, std::move(ptr), std::move(promise_));
  }

  void on_error(Status status) final {
    td_->web_pages_manager_->on_get_web_page_preview_fail(request_id_, url_, std::move(status), std::move(promise_));
  }
};

class GetWebPageQuery final : public Td::ResultHandler {
  Promise<WebPageId> promise_;
  WebPageId web_page_id_;
  string url_;

 public:
  explicit GetWebPageQuery(Promise<WebPageId> &&promise) : promise_(std::move(promise)) {
  }

  void send(WebPageId web_page_id, const string &url, int32 hash) {
    web_page_id_ = web_page_id;
    url_ = url;
    send_query(G()->net_query_creator().create(telegram_api::messages_getWebPage(url, hash)));
  }

  void on_result(BufferSlice packet) final {
    auto result_ptr = fetch_result<telegram_api::messages_getWebPage>(packet);
    if (result_ptr.is_error()) {
      return on_error(result_ptr.move_as_error());
    }

    auto ptr = result_ptr.move_as_ok();
    LOG(INFO) << ""Receive result for GetWebPageQuery: "" << to_string(ptr);
    if (ptr->get_id() == telegram_api::webPageNotModified::ID) {
      if (web_page_id_.is_valid()) {
        auto web_page = move_tl_object_as<telegram_api::webPageNotModified>(ptr);
        int32 view_count = (web_page->flags_ & telegram_api::webPageNotModified::CACHED_PAGE_VIEWS_MASK) != 0
                               ? web_page->cached_page_views_
                               : 0;
        td_->web_pages_manager_->on_get_web_page_instant_view_view_count(web_page_id_, view_count);
        return promise_.set_value(std::move(web_page_id_));
      } else {
        LOG(ERROR) << ""Receive webPageNotModified for "" << url_;
        return on_error(Status::Error(500, ""Receive webPageNotModified""));
      }
    }
    auto web_page_id = td_->web_pages_manager_->on_get_web_page(std::move(ptr), DialogId());
    td_->web_pages_manager_->on_get_web_page_by_url(url_, web_page_id, false);
    promise_.set_value(std::move(web_page_id));
  }

  void on_error(Status status) final {
    promise_.set_error(std::move(status));
  }
};

class WebPagesManager::WebPageInstantView {
 public:
  vector<unique_ptr<WebPageBlock>> page_blocks;
  string url;
  int32 view_count = 0;
  int32 hash = 0;
  bool is_v2 = false;
  bool is_rtl = false;
  bool is_empty = true;
  bool is_full = false;
  bool is_loaded = false;
  bool was_loaded_from_database = false;

  template <class StorerT>
  void store(StorerT &storer) const {
    using ::td::store;
    bool has_url = !url.empty();
    bool has_view_count = view_count > 0;
    BEGIN_STORE_FLAGS();
    STORE_FLAG(is_full);
    STORE_FLAG(is_loaded);
    STORE_FLAG(is_rtl);
    STORE_FLAG(is_v2);
    STORE_FLAG(has_url);
    STORE_FLAG(has_view_count);
    END_STORE_FLAGS();

    store(page_blocks, storer);
    store(hash, storer);
    if (has_url) {
      store(url, storer);
    }
    if (has_view_count) {
      store(view_count, storer);
    }
    CHECK(!is_empty);
  }

  template <class ParserT>
  void parse(ParserT &parser) {
    using ::td::parse;
    bool has_url;
    bool has_view_count;
    BEGIN_PARSE_FLAGS();
    PARSE_FLAG(is_full);
    PARSE_FLAG(is_loaded);
    PARSE_FLAG(is_rtl);
    PARSE_FLAG(is_v2);
    PARSE_FLAG(has_url);
    PARSE_FLAG(has_view_count);
    END_PARSE_FLAGS();

    parse(page_blocks, parser);
    parse(hash, parser);
    if (has_url) {
      parse(url, parser);
    }
    if (has_view_count) {
      parse(view_count, parser);
    }
    is_empty = false;
  }

  friend StringBuilder &operator<<(StringBuilder &string_builder,
                                   const WebPagesManager::WebPageInstantView &instant_view) {
    return string_builder << ""InstantView(url = "" << instant_view.url << "", size = "" << instant_view.page_blocks.size()
                          << "", view_count = "" << instant_view.view_count << "", hash = "" << instant_view.hash
                          << "", is_empty = "" << instant_view.is_empty << "", is_v2 = "" << instant_view.is_v2
                          << "", is_rtl = "" << instant_view.is_rtl << "", is_full = "" << instant_view.is_full
                          << "", is_loaded = "" << instant_view.is_loaded
                          << "", was_loaded_from_database = "" << instant_view.was_loaded_from_database << "")"";
  }
};

class WebPagesManager::WebPage {
 public:
  string url;
  string display_url;
  string type;
  string site_name;
  string title;
  string description;
  Photo photo;
  string embed_url;
  string embed_type;
  Dimensions embed_dimensions;
  int32 duration = 0;
  string author;
  Document document;
  vector<Document> documents;
  WebPageInstantView instant_view;

  FileSourceId file_source_id;

  mutable uint64 log_event_id = 0;

  template <class StorerT>
  void store(StorerT &storer) const {
    using ::td::store;
    bool has_type = !type.empty();
    bool has_site_name = !site_name.empty();
    bool has_title = !title.empty();
    bool has_description = !description.empty();
    bool has_photo = !photo.is_empty();
    bool has_embed = !embed_url.empty();
    bool has_embed_dimensions = has_embed && embed_dimensions != Dimensions();
    bool has_duration = duration > 0;
    bool has_author = !author.empty();
    bool has_document = !document.empty();
    bool has_instant_view = !instant_view.is_empty;
    bool is_instant_view_v2 = instant_view.is_v2;
    bool has_no_hash = true;
    bool has_documents = !documents.empty();
    BEGIN_STORE_FLAGS();
    STORE_FLAG(has_type);
    STORE_FLAG(has_site_name);
    STORE_FLAG(has_title);
    STORE_FLAG(has_description);
    STORE_FLAG(has_photo);
    STORE_FLAG(has_embed);
    STORE_FLAG(has_embed_dimensions);
    STORE_FLAG(has_duration);
    STORE_FLAG(has_author);
    STORE_FLAG(has_document);
    STORE_FLAG(has_instant_view);
    STORE_FLAG(has_no_hash);
    STORE_FLAG(is_instant_view_v2);
    STORE_FLAG(has_documents);
    END_STORE_FLAGS();

    store(url, storer);
    store(display_url, storer);
    if (has_type) {
      store(type, storer);
    }
    if (has_site_name) {
      store(site_name, storer);
    }
    if (has_title) {
      store(title, storer);
    }
    if (has_description) {
      store(description, storer);
    }
    if (has_photo) {
      store(photo, storer);
    }
    if (has_embed) {
      store(embed_url, storer);
      store(embed_type, storer);
    }
    if (has_embed_dimensions) {
      store(embed_dimensions, storer);
    }
    if (has_duration) {
      store(duration, storer);
    }
    if (has_author) {
      store(author, storer);
    }
    if (has_document) {
      store(document, storer);
    }
    if (has_documents) {
      store(documents, storer);
    }
  }

  template <class ParserT>
  void parse(ParserT &parser) {
    using ::td::parse;
    bool has_type;
    bool has_site_name;
    bool has_title;
    bool has_description;
    bool has_photo;
    bool has_embed;
    bool has_embed_dimensions;
    bool has_duration;
    bool has_author;
    bool has_document;
    bool has_instant_view;
    bool is_instant_view_v2;
    bool has_no_hash;
    bool has_documents;
    BEGIN_PARSE_FLAGS();
    PARSE_FLAG(has_type);
    PARSE_FLAG(has_site_name);
    PARSE_FLAG(has_title);
    PARSE_FLAG(has_description);
    PARSE_FLAG(has_photo);
    PARSE_FLAG(has_embed);
    PARSE_FLAG(has_embed_dimensions);
    PARSE_FLAG(has_duration);
    PARSE_FLAG(has_author);
    PARSE_FLAG(has_document);
    PARSE_FLAG(has_instant_view);
    PARSE_FLAG(has_no_hash);
    PARSE_FLAG(is_instant_view_v2);
    PARSE_FLAG(has_documents);
    END_PARSE_FLAGS();

    parse(url, parser);
    parse(display_url, parser);
    if (!has_no_hash) {
      int32 hash;
      parse(hash, parser);
    }
    if (has_type) {
      parse(type, parser);
    }
    if (has_site_name) {
      parse(site_name, parser);
    }
    if (has_title) {
      parse(title, parser);
    }
    if (has_description) {
      parse(description, parser);
    }
    if (has_photo) {
      parse(photo, parser);
    }
    if (has_embed) {
      parse(embed_url, parser);
      parse(embed_type, parser);
    }
    if (has_embed_dimensions) {
      parse(embed_dimensions, parser);
    }
    if (has_duration) {
      parse(duration, parser);
    }
    if (has_author) {
      parse(author, parser);
    }
    if (has_document) {
      parse(document, parser);
    }
    if (has_documents) {
      parse(documents, parser);
    }

    if (has_instant_view) {
      instant_view.is_empty = false;
    }
    if (is_instant_view_v2) {
      instant_view.is_v2 = true;
    }
  }

  friend bool operator==(const WebPage &lhs, const WebPage &rhs) {
    return lhs.url == rhs.url && lhs.display_url == rhs.display_url && lhs.type == rhs.type &&
           lhs.site_name == rhs.site_name && lhs.title == rhs.title && lhs.description == rhs.description &&
           lhs.photo == rhs.photo && lhs.type == rhs.type && lhs.embed_url == rhs.embed_url &&
           lhs.embed_type == rhs.embed_type && lhs.embed_dimensions == rhs.embed_dimensions &&
           lhs.duration == rhs.duration && lhs.author == rhs.author && lhs.document == rhs.document &&
           lhs.documents == rhs.documents && lhs.instant_view.is_empty == rhs.instant_view.is_empty &&
           lhs.instant_view.is_v2 == rhs.instant_view.is_v2;
  }
};

WebPagesManager::WebPagesManager(Td *td, ActorShared<> parent) : td_(td), parent_(std::move(parent)) {
  pending_web_pages_timeout_.set_callback(on_pending_web_page_timeout_callback);
  pending_web_pages_timeout_.set_callback_data(static_cast<void *>(this));
}

void WebPagesManager::tear_down() {
  parent_.reset();
}

WebPagesManager::~WebPagesManager() = default;

WebPageId WebPagesManager::on_get_web_page(tl_object_ptr<telegram_api::WebPage> &&web_page_ptr,
                                           DialogId owner_dialog_id) {
  CHECK(web_page_ptr != nullptr);
  LOG(DEBUG) << ""Got "" << to_string(web_page_ptr);
  switch (web_page_ptr->get_id()) {
    case telegram_api::webPageEmpty::ID: {
      auto web_page = move_tl_object_as<telegram_api::webPageEmpty>(web_page_ptr);
      WebPageId web_page_id(web_page->id_);
      if (!web_page_id.is_valid()) {
        LOG_IF(ERROR, web_page_id != WebPageId()) << ""Receive invalid "" << web_page_id;
        return WebPageId();
      }

      LOG(INFO) << ""Got empty "" << web_page_id;
      const WebPage *web_page_to_delete = get_web_page(web_page_id);
      if (web_page_to_delete != nullptr) {
        if (web_page_to_delete->log_event_id != 0) {
          LOG(INFO) << ""Erase "" << web_page_id << "" from binlog"";
          binlog_erase(G()->td_db()->get_binlog(), web_page_to_delete->log_event_id);
          web_page_to_delete->log_event_id = 0;
        }
        if (web_page_to_delete->file_source_id.is_valid()) {
          td_->file_manager_->change_files_source(web_page_to_delete->file_source_id,
                                                  get_web_page_file_ids(web_page_to_delete), vector<FileId>());
        }
        web_pages_.erase(web_page_id);
      }

      on_web_page_changed(web_page_id, false);
      if (G()->parameters().use_message_db) {
        LOG(INFO) << ""Delete "" << web_page_id << "" from database"";
        G()->td_db()->get_sqlite_pmc()->erase(get_web_page_database_key(web_page_id), Auto());
        G()->td_db()->get_sqlite_pmc()->erase(get_web_page_instant_view_database_key(web_page_id), Auto());
      }

      return WebPageId();
    }
    case telegram_api::webPagePending::ID: {
      auto web_page = move_tl_object_as<telegram_api::webPagePending>(web_page_ptr);
      WebPageId web_page_id(web_page->id_);
      if (!web_page_id.is_valid()) {
        LOG(ERROR) << ""Receive invalid "" << web_page_id;
        return WebPageId();
      }

      auto web_page_date = web_page->date_;
      LOG(INFO) << ""Got pending "" << web_page_id << "", force_get_date = "" << web_page_date
                << "", now = "" << G()->server_time();

      pending_web_pages_timeout_.add_timeout_in(web_page_id.get(), max(web_page_date - G()->server_time(), 1.0));
      return web_page_id;
    }
    case telegram_api::webPage::ID: {
      auto web_page = move_tl_object_as<telegram_api::webPage>(web_page_ptr);
      WebPageId web_page_id(web_page->id_);
      if (!web_page_id.is_valid()) {
        LOG(ERROR) << ""Receive invalid "" << web_page_id;
        return WebPageId();
      }

      LOG(INFO) << ""Got "" << web_page_id;
      auto page = make_unique<WebPage>();

      page->url = std::move(web_page->url_);
      page->display_url = std::move(web_page->display_url_);
      page->type = std::move(web_page->type_);
      page->site_name = std::move(web_page->site_name_);
      page->title = std::move(web_page->title_);
      page->description = std::move(web_page->description_);
      page->photo = get_photo(td_->file_manager_.get(), std::move(web_page->photo_), owner_dialog_id);
      if (web_page->flags_ & WEBPAGE_FLAG_HAS_EMBEDDED_PREVIEW) {
        page->embed_url = std::move(web_page->embed_url_);
        page->embed_type = std::move(web_page->embed_type_);
      }
      if (web_page->flags_ & WEBPAGE_FLAG_HAS_EMBEDDED_PREVIEW_SIZE) {
        page->embed_dimensions = get_dimensions(web_page->embed_width_, web_page->embed_height_, ""webPage"");
      }
      if (web_page->flags_ & WEBPAGE_FLAG_HAS_DURATION) {
        page->duration = web_page->duration_;
        if (page->duration < 0) {
          LOG(ERROR) << ""Receive wrong web page duration "" << page->duration;
          page->duration = 0;
        }
      }
      if (web_page->flags_ & WEBPAGE_FLAG_HAS_AUTHOR) {
        page->author = std::move(web_page->author_);
      }
      if (web_page->flags_ & WEBPAGE_FLAG_HAS_DOCUMENT) {
        int32 document_id = web_page->document_->get_id();
        if (document_id == telegram_api::document::ID) {
          auto parsed_document = td_->documents_manager_->on_get_document(
              move_tl_object_as<telegram_api::document>(web_page->document_), owner_dialog_id);
          page->document = std::move(parsed_document);
        }
      }
      for (auto &attribute : web_page->attributes_) {
        CHECK(attribute != nullptr);
        page->documents.clear();
        for (auto &document : attribute->documents_) {
          int32 document_id = document->get_id();
          if (document_id == telegram_api::document::ID) {
            auto parsed_document = td_->documents_manager_->on_get_document(
                move_tl_object_as<telegram_api::document>(document), owner_dialog_id);
            if (!parsed_document.empty()) {
              page->documents.push_back(std::move(parsed_document));
            }
          }
        }
        // TODO attribute->settings_
      }
      if (web_page->flags_ & WEBPAGE_FLAG_HAS_INSTANT_VIEW) {
        on_get_web_page_instant_view(page.get(), std::move(web_page->cached_page_), web_page->hash_, owner_dialog_id);
      }

      update_web_page(std::move(page), web_page_id, false, false);
      return web_page_id;
    }
    case telegram_api::webPageNotModified::ID: {
      LOG(ERROR) << ""Receive webPageNotModified"";
      return WebPageId();
    }
    default:
      UNREACHABLE();
      return WebPageId();
  }
}

void WebPagesManager::update_web_page(unique_ptr<WebPage> web_page, WebPageId web_page_id, bool from_binlog,
                                      bool from_database) {
  LOG(INFO) << ""Update "" << web_page_id << (from_database ? "" from database"" : (from_binlog ? "" from binlog"" : """"));
  CHECK(web_page != nullptr);

  auto &page = web_pages_[web_page_id];
  auto old_file_ids = get_web_page_file_ids(page.get());
  WebPageInstantView old_instant_view;
  bool is_changed = true;
  if (page != nullptr) {
    if (*page == *web_page) {
      is_changed = false;
    }

    old_instant_view = std::move(page->instant_view);
    web_page->log_event_id = page->log_event_id;
  } else {
    auto it = url_to_file_source_id_.find(web_page->url);
    if (it != url_to_file_source_id_.end()) {
      VLOG(file_references) << ""Move "" << it->second << "" inside of "" << web_page_id;
      web_page->file_source_id = it->second;
      url_to_file_source_id_.erase(it);
    }
  }
  page = std::move(web_page);

  update_web_page_instant_view(web_page_id, page->instant_view, std::move(old_instant_view));

  auto new_file_ids = get_web_page_file_ids(page.get());
  if (old_file_ids != new_file_ids) {
    td_->file_manager_->change_files_source(get_web_page_file_source_id(page.get()), old_file_ids, new_file_ids);
  }

  on_get_web_page_by_url(page->url, web_page_id, from_database);

  if (is_changed && !from_database) {
    on_web_page_changed(web_page_id, true);

    save_web_page(page.get(), web_page_id, from_binlog);
  }
}

void WebPagesManager::update_web_page_instant_view(WebPageId web_page_id, WebPageInstantView &new_instant_view,
                                                   WebPageInstantView &&old_instant_view) {
  LOG(INFO) << ""Merge new "" << new_instant_view << "" and old "" << old_instant_view;

  bool new_from_database = new_instant_view.was_loaded_from_database;
  bool old_from_database = old_instant_view.was_loaded_from_database;

  if (new_instant_view.is_empty && !new_from_database) {
    // new_instant_view is from server and is empty, need to delete the instant view
    if (G()->parameters().use_message_db && (!old_instant_view.is_empty || !old_from_database)) {
      // we have no instant view and probably want it to be deleted from database
      LOG(INFO) << ""Erase instant view of "" << web_page_id << "" from database"";
      new_instant_view.was_loaded_from_database = true;
      G()->td_db()->get_sqlite_pmc()->erase(get_web_page_instant_view_database_key(web_page_id), Auto());
    }
    return;
  }

  if (need_use_old_instant_view(new_instant_view, old_instant_view)) {
    new_instant_view = std::move(old_instant_view);
  }

  if (G()->parameters().use_message_db && !new_instant_view.is_empty && new_instant_view.is_loaded) {
    // we have instant view and probably want it to be saved
    if (!new_from_database && !old_from_database) {
      // if it wasn't loaded from the database, load it first
      auto &load_web_page_instant_view_queries = load_web_page_instant_view_queries_[web_page_id];
      auto previous_queries =
          load_web_page_instant_view_queries.partial.size() + load_web_page_instant_view_queries.full.size();
      if (previous_queries == 0) {
        // try to load it only if there are no pending load queries
        load_web_page_instant_view(web_page_id, false, Auto());
        return;
      }
    }

    if (!new_instant_view.was_loaded_from_database) {
      LOG(INFO) << ""Save instant view of "" << web_page_id << "" to database"";
      /*
      if (web_page_id.get() == 0) {
        auto blocks = std::move(new_instant_view.page_blocks);
        new_instant_view.page_blocks.clear();
        for (size_t i = 0; i < blocks.size(); i++) {
          LOG(ERROR) << to_string(blocks[i]->get_page_block_object());
          new_instant_view.page_blocks.push_back(std::move(blocks[i]));
          log_event_store(new_instant_view);
        }
        UNREACHABLE();
      }
      */
      new_instant_view.was_loaded_from_database = true;
      G()->td_db()->get_sqlite_pmc()->set(get_web_page_instant_view_database_key(web_page_id),
                                          log_event_store(new_instant_view).as_slice().str(), Auto());
    }
  }
}

bool WebPagesManager::need_use_old_instant_view(const WebPageInstantView &new_instant_view,
                                                const WebPageInstantView &old_instant_view) {
  if (old_instant_view.is_empty || !old_instant_view.is_loaded) {
    return false;
  }
  if (new_instant_view.is_empty || !new_instant_view.is_loaded) {
    return true;
  }
  if (new_instant_view.is_full != old_instant_view.is_full) {
    return old_instant_view.is_full;
  }

  if (new_instant_view.hash == old_instant_view.hash) {
    // the same instant view
    return !new_instant_view.is_full || old_instant_view.is_full;
  }

  // data in database is always outdated
  return new_instant_view.was_loaded_from_database;
}

void WebPagesManager::on_get_web_page_instant_view_view_count(WebPageId web_page_id, int32 view_count) {
  if (get_web_page_instant_view(web_page_id) == nullptr) {
    return;
  }

  auto *instant_view = &web_pages_[web_page_id]->instant_view;
  CHECK(!instant_view->is_empty);
  if (instant_view->view_count >= view_count) {
    return;
  }
  instant_view->view_count = view_count;
  if (G()->parameters().use_message_db) {
    LOG(INFO) << ""Save instant view of "" << web_page_id << "" to database after updating view count to "" << view_count;
    G()->td_db()->get_sqlite_pmc()->set(get_web_page_instant_view_database_key(web_page_id),
                                        log_event_store(*instant_view).as_slice().str(), Auto());
  }
}

void WebPagesManager::on_get_web_page_by_url(const string &url, WebPageId web_page_id, bool from_database) {
  auto &cached_web_page_id = url_to_web_page_id_[url];
  if (!from_database && G()->parameters().use_message_db) {
    if (web_page_id.is_valid()) {
      if (cached_web_page_id != web_page_id) {  // not already saved
        G()->td_db()->get_sqlite_pmc()->set(get_web_page_url_database_key(url), to_string(web_page_id.get()), Auto());
      }
    } else {
      G()->td_db()->get_sqlite_pmc()->erase(get_web_page_url_database_key(url), Auto());
    }
  }

  if (cached_web_page_id.is_valid() && web_page_id.is_valid() && web_page_id != cached_web_page_id) {
    LOG(ERROR) << ""Url \\"""" << url << ""\\"" preview is changed from "" << cached_web_page_id << "" to "" << web_page_id;
  }

  cached_web_page_id = web_page_id;
}

void WebPagesManager::register_web_page(WebPageId web_page_id, FullMessageId full_message_id, const char *source) {
  if (!web_page_id.is_valid()) {
    return;
  }

  LOG(INFO) << ""Register "" << web_page_id << "" from "" << full_message_id << "" from "" << source;
  bool is_inserted = web_page_messages_[web_page_id].insert(full_message_id).second;
  LOG_CHECK(is_inserted) << source << "" "" << web_page_id << "" "" << full_message_id;

  if (!td_->auth_manager_->is_bot() && !have_web_page_force(web_page_id)) {
    LOG(INFO) << ""Waiting for "" << web_page_id << "" needed in "" << full_message_id;
    pending_web_pages_timeout_.add_timeout_in(web_page_id.get(), 1.0);
  }
}

void WebPagesManager::unregister_web_page(WebPageId web_page_id, FullMessageId full_message_id, const char *source) {
  if (!web_page_id.is_valid()) {
    return;
  }

  LOG(INFO) << ""Unregister "" << web_page_id << "" from "" << full_message_id << "" from "" << source;
  auto &message_ids = web_page_messages_[web_page_id];
  auto is_deleted = message_ids.erase(full_message_id) > 0;
  LOG_CHECK(is_deleted) << source << "" "" << web_page_id << "" "" << full_message_id;

  if (message_ids.empty()) {
    web_page_messages_.erase(web_page_id);
    if (pending_get_web_pages_.count(web_page_id) == 0) {
      pending_web_pages_timeout_.cancel_timeout(web_page_id.get());
    }
  }
}

void WebPagesManager::on_get_web_page_preview_success(int64 request_id, const string &url,
                                                      tl_object_ptr<telegram_api::MessageMedia> &&message_media_ptr,
                                                      Promise<Unit> &&promise) {
  CHECK(message_media_ptr != nullptr);
  int32 constructor_id = message_media_ptr->get_id();
  if (constructor_id != telegram_api::messageMediaWebPage::ID) {
    if (constructor_id == telegram_api::messageMediaEmpty::ID) {
      on_get_web_page_preview_success(request_id, url, WebPageId(), std::move(promise));
      return;
    }

    LOG(ERROR) << ""Receive "" << to_string(message_media_ptr) << "" instead of web page"";
    on_get_web_page_preview_fail(request_id, url, Status::Error(500, ""Receive not web page in GetWebPagePreview""),
                                 std::move(promise));
    return;
  }

  auto message_media_web_page = move_tl_object_as<telegram_api::messageMediaWebPage>(message_media_ptr);
  CHECK(message_media_web_page->webpage_ != nullptr);

  auto web_page_id = on_get_web_page(std::move(message_media_web_page->webpage_), DialogId());
  if (web_page_id.is_valid() && !have_web_page(web_page_id)) {
    pending_get_web_pages_[web_page_id].emplace(request_id,
                                                std::make_pair(url, std::move(promise)));  // TODO MultiPromise ?
    return;
  }

  on_get_web_page_preview_success(request_id, url, web_page_id, std::move(promise));
}

void WebPagesManager::on_get_web_page_preview_success(int64 request_id, const string &url, WebPageId web_page_id,
                                                      Promise<Unit> &&promise) {
  CHECK(web_page_id == WebPageId() || have_web_page(web_page_id));

  CHECK(got_web_page_previews_.find(request_id) == got_web_page_previews_.end());
  got_web_page_previews_[request_id] = web_page_id;

  if (web_page_id.is_valid() && !url.empty()) {
    on_get_web_page_by_url(url, web_page_id, true);
  }

  promise.set_value(Unit());
}

void WebPagesManager::on_get_web_page_preview_fail(int64 request_id, const string &url, Status error,
                                                   Promise<Unit> &&promise) {
  LOG(INFO) << ""Clean up getting of web page preview with url \\"""" << url << '""';
  CHECK(error.is_error());
  promise.set_error(std::move(error));
}

int64 WebPagesManager::get_web_page_preview(td_api::object_ptr<td_api::formattedText> &&text, Promise<Unit> &&promise) {
  if (text == nullptr) {
    promise.set_value(Unit());
    return 0;
  }

  auto r_entities = get_message_entities(td_->contacts_manager_.get(), std::move(text->entities_));
  if (r_entities.is_error()) {
    promise.set_error(r_entities.move_as_error());
    return 0;
  }
  auto entities = r_entities.move_as_ok();

  auto result = fix_formatted_text(text->text_, entities, true, false, true, true, false);
  if (result.is_error() || text->text_.empty()) {
    promise.set_value(Unit());
    return 0;
  }

  auto url = get_first_url(text->text_, entities);
  if (url.empty()) {
    promise.set_value(Unit());
    return 0;
  }

  LOG(INFO) << ""Trying to get web page preview for message \\"""" << text->text_ << '""';
  int64 request_id = get_web_page_preview_request_id_++;

  auto web_page_id = get_web_page_by_url(url);
  if (web_page_id.is_valid()) {
    got_web_page_previews_[request_id] = web_page_id;
    promise.set_value(Unit());
  } else {
    td_->create_handler<GetWebPagePreviewQuery>(std::move(promise))
        ->send(text->text_, get_input_message_entities(td_->contacts_manager_.get(), entities, ""get_web_page_preview""),
               request_id, std::move(url));
  }
  return request_id;
}

tl_object_ptr<td_api::webPage> WebPagesManager::get_web_page_preview_result(int64 request_id) {
  if (request_id == 0) {
    return nullptr;
  }

  auto it = got_web_page_previews_.find(request_id);
  CHECK(it != got_web_page_previews_.end());
  auto web_page_id = it->second;
  got_web_page_previews_.erase(it);
  return get_web_page_object(web_page_id);
}

void WebPagesManager::get_web_page_instant_view(const string &url, bool force_full, Promise<WebPageId> &&promise) {
  LOG(INFO) << ""Trying to get web page instant view for the url \\"""" << url << '""';
  auto it = url_to_web_page_id_.find(url);
  if (it != url_to_web_page_id_.end()) {
    if (it->second == WebPageId()) {
      // ignore negative caching
      return reload_web_page_by_url(url, std::move(promise));
    }
    return get_web_page_instant_view(it->second, force_full, std::move(promise));
  }

  load_web_page_by_url(url, std::move(promise));
}

void WebPagesManager::get_web_page_instant_view(WebPageId web_page_id, bool force_full, Promise<WebPageId> &&promise) {
  LOG(INFO) << ""Trying to get web page instant view for "" << web_page_id;

  const WebPageInstantView *web_page_instant_view = get_web_page_instant_view(web_page_id);
  if (web_page_instant_view == nullptr) {
    return promise.set_value(WebPageId());
  }

  if (!web_page_instant_view->is_loaded || (force_full && !web_page_instant_view->is_full)) {
    return load_web_page_instant_view(web_page_id, force_full, std::move(promise));
  }

  if (force_full) {
    reload_web_page_instant_view(web_page_id);
  }

  promise.set_value(std::move(web_page_id));
}

string WebPagesManager::get_web_page_instant_view_database_key(WebPageId web_page_id) {
  return PSTRING() << ""wpiv"" << web_page_id.get();
}

void WebPagesManager::load_web_page_instant_view(WebPageId web_page_id, bool force_full, Promise<WebPageId> &&promise) {
  auto &load_web_page_instant_view_queries = load_web_page_instant_view_queries_[web_page_id];
  auto previous_queries =
      load_web_page_instant_view_queries.partial.size() + load_web_page_instant_view_queries.full.size();
  if (force_full) {
    load_web_page_instant_view_queries.full.push_back(std::move(promise));
  } else {
    load_web_page_instant_view_queries.partial.push_back(std::move(promise));
  }
  LOG(INFO) << ""Load "" << web_page_id << "" instant view, have "" << previous_queries << "" previous queries"";
  if (previous_queries == 0) {
    const WebPageInstantView *web_page_instant_view = get_web_page_instant_view(web_page_id);
    CHECK(web_page_instant_view != nullptr);

    if (G()->parameters().use_message_db && !web_page_instant_view->was_loaded_from_database) {
      LOG(INFO) << ""Trying to load "" << web_page_id << "" instant view from database"";
      G()->td_db()->get_sqlite_pmc()->get(
          get_web_page_instant_view_database_key(web_page_id),
          PromiseCreator::lambda([actor_id = actor_id(this), web_page_id](string value) {
            send_closure(actor_id, &WebPagesManager::on_load_web_page_instant_view_from_database, web_page_id,
                         std::move(value));
          }));
    } else {
      reload_web_page_instant_view(web_page_id);
    }
  }
}

void WebPagesManager::reload_web_page_instant_view(WebPageId web_page_id) {
  LOG(INFO) << ""Reload "" << web_page_id << "" instant view"";
  const WebPage *web_page = get_web_page(web_page_id);
  CHECK(web_page != nullptr && !web_page->instant_view.is_empty);

  auto promise = PromiseCreator::lambda([actor_id = actor_id(this), web_page_id](Result<WebPageId> result) {
    send_closure(actor_id, &WebPagesManager::update_web_page_instant_view_load_requests, web_page_id, true,
                 std::move(result));
  });

  TRY_STATUS_PROMISE(promise, G()->close_status());

  td_->create_handler<GetWebPageQuery>(std::move(promise))
      ->send(web_page_id, web_page->url, web_page->instant_view.is_full ? web_page->instant_view.hash : 0);
}

void WebPagesManager::on_load_web_page_instant_view_from_database(WebPageId web_page_id, string value) {
  if (G()->close_flag()) {
    return;
  }
  CHECK(G()->parameters().use_message_db);
  LOG(INFO) << ""Successfully loaded "" << web_page_id << "" instant view of size "" << value.size() << "" from database"";
  //  G()->td_db()->get_sqlite_pmc()->erase(get_web_page_instant_view_database_key(web_page_id), Auto());
  //  value.clear();

  auto web_page_it = web_pages_.find(web_page_id);
  if (web_page_it == web_pages_.end() || web_page_it->second->instant_view.is_empty) {
    // possible if web page loses preview/instant view
    LOG(WARNING) << ""There is no instant view in "" << web_page_id;
    if (!value.empty()) {
      G()->td_db()->get_sqlite_pmc()->erase(get_web_page_instant_view_database_key(web_page_id), Auto());
    }
    update_web_page_instant_view_load_requests(web_page_id, true, web_page_id);
    return;
  }
  WebPage *web_page = web_page_it->second.get();
  auto &web_page_instant_view = web_page->instant_view;
  if (web_page_instant_view.was_loaded_from_database) {
    return;
  }

  WebPageInstantView result;
  if (!value.empty()) {
    auto status = log_event_parse(result, value);
    if (status.is_error()) {
      result = WebPageInstantView();

      LOG(ERROR) << ""Erase instant view in "" << web_page_id << "" from database because of "" << status.message();
      G()->td_db()->get_sqlite_pmc()->erase(get_web_page_instant_view_database_key(web_page_id), Auto());
    }
  }
  result.was_loaded_from_database = true;

  auto old_file_ids = get_web_page_file_ids(web_page);

  update_web_page_instant_view(web_page_id, web_page_instant_view, std::move(result));

  auto new_file_ids = get_web_page_file_ids(web_page);
  if (old_file_ids != new_file_ids) {
    td_->file_manager_->change_files_source(get_web_page_file_source_id(web_page), old_file_ids, new_file_ids);
  }

  update_web_page_instant_view_load_requests(web_page_id, false, web_page_id);
}

void WebPagesManager::update_web_page_instant_view_load_requests(WebPageId web_page_id, bool force_update,
                                                                 Result<WebPageId> r_web_page_id) {
  if (G()->close_flag()) {
    r_web_page_id = Global::request_aborted_error();
  }
  LOG(INFO) << ""Update load requests for "" << web_page_id;
  auto it = load_web_page_instant_view_queries_.find(web_page_id);
  if (it == load_web_page_instant_view_queries_.end()) {
    return;
  }
  vector<Promise<WebPageId>> promises[2];
  promises[0] = std::move(it->second.partial);
  promises[1] = std::move(it->second.full);
  reset_to_empty(it->second.partial);
  reset_to_empty(it->second.full);
  load_web_page_instant_view_queries_.erase(it);

  if (r_web_page_id.is_error()) {
    LOG(INFO) << ""Receive error "" << r_web_page_id.error() << "" for load "" << web_page_id;
    combine(promises[0], std::move(promises[1]));
    for (auto &promise : promises[0]) {
      promise.set_error(r_web_page_id.error().clone());
    }
    return;
  }

  auto new_web_page_id = r_web_page_id.move_as_ok();
  LOG(INFO) << ""Successfully loaded web page "" << web_page_id << "" as "" << new_web_page_id;
  const WebPageInstantView *web_page_instant_view = get_web_page_instant_view(new_web_page_id);
  if (web_page_instant_view == nullptr) {
    combine(promises[0], std::move(promises[1]));
    for (auto &promise : promises[0]) {
      promise.set_value(WebPageId());
    }
    return;
  }
  if (web_page_instant_view->is_loaded) {
    if (web_page_instant_view->is_full) {
      combine(promises[0], std::move(promises[1]));
    }

    for (auto &promise : promises[0]) {
      promise.set_value(WebPageId(new_web_page_id));
    }
    reset_to_empty(promises[0]);
  }
  if (!promises[0].empty() || !promises[1].empty()) {
    if (force_update) {
      // protection from cycles
      LOG(ERROR) << ""Expected to receive "" << web_page_id << '/' << new_web_page_id
                 << "" from the server, but didn't receive it"";
      combine(promises[0], std::move(promises[1]));
      for (auto &promise : promises[0]) {
        promise.set_value(WebPageId());
      }
      return;
    }
    auto &load_queries = load_web_page_instant_view_queries_[new_web_page_id];
    auto old_size = load_queries.partial.size() + load_queries.full.size();
    combine(load_queries.partial, std::move(promises[0]));
    combine(load_queries.full, std::move(promises[1]));
    if (old_size == 0) {
      reload_web_page_instant_view(new_web_page_id);
    }
  }
}

WebPageId WebPagesManager::get_web_page_by_url(const string &url) const {
  if (url.empty()) {
    return WebPageId();
  }

  LOG(INFO) << ""Get web page identifier for the url \\"""" << url << '""';

  auto it = url_to_web_page_id_.find(url);
  if (it != url_to_web_page_id_.end()) {
    return it->second;
  }

  return WebPageId();
}

void WebPagesManager::get_web_page_by_url(const string &url, Promise<WebPageId> &&promise) {
  LOG(INFO) << ""Trying to get web page identifier for the url \\"""" << url << '""';

  auto it = url_to_web_page_id_.find(url);
  if (it != url_to_web_page_id_.end()) {
    return promise.set_value(WebPageId(it->second));
  }

  load_web_page_by_url(url, std::move(promise));
}

void WebPagesManager::load_web_page_by_url(string url, Promise<WebPageId> &&promise) {
  if (!G()->parameters().use_message_db) {
    return reload_web_page_by_url(url, std::move(promise));
  }

  LOG(INFO) << ""Load \\"""" << url << '""';
  auto key = get_web_page_url_database_key(url);
  G()->td_db()->get_sqlite_pmc()->get(key, PromiseCreator::lambda([actor_id = actor_id(this), url = std::move(url),
                                                                   promise = std::move(promise)](string value) mutable {
                                        send_closure(actor_id,
                                                     &WebPagesManager::on_load_web_page_id_by_url_from_database,
                                                     std::move(url), std::move(value), std::move(promise));
                                      }));
}

void WebPagesManager::on_load_web_page_id_by_url_from_database(string url, string value, Promise<WebPageId> &&promise) {
  TRY_STATUS_PROMISE(promise, G()->close_status());

  LOG(INFO) << ""Successfully loaded url \\"""" << url << ""\\"" of size "" << value.size() << "" from database"";
  //  G()->td_db()->get_sqlite_pmc()->erase(get_web_page_url_database_key(web_page_id), Auto());
  //  value.clear();

  auto it = url_to_web_page_id_.find(url);
  if (it != url_to_web_page_id_.end()) {
    // URL web page has already been loaded
    return promise.set_value(WebPageId(it->second));
  }
  if (!value.empty()) {
    auto web_page_id = WebPageId(to_integer<int64>(value));
    if (web_page_id.is_valid()) {
      if (have_web_page(web_page_id)) {
        // URL web page has already been loaded
        on_get_web_page_by_url(url, web_page_id, true);
        promise.set_value(WebPageId(web_page_id));
        return;
      }

      load_web_page_from_database(web_page_id,
                                  PromiseCreator::lambda([actor_id = actor_id(this), web_page_id, url = std::move(url),
                                                          promise = std::move(promise)](Result<Unit> result) mutable {
                                    send_closure(actor_id, &WebPagesManager::on_load_web_page_by_url_from_database,
                                                 web_page_id, std::move(url), std::move(promise), std::move(result));
                                  }));
      return;
    } else {
      LOG(ERROR) << ""Receive invalid "" << web_page_id;
    }
  }

  reload_web_page_by_url(url, std::move(promise));
}

void WebPagesManager::on_load_web_page_by_url_from_database(WebPageId web_page_id, string url,
                                                            Promise<WebPageId> &&promise, Result<Unit> &&result) {
  if (result.is_error()) {
    CHECK(G()->close_flag());
    return promise.set_error(Global::request_aborted_error());
  }

  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr) {
    return reload_web_page_by_url(url, std::move(promise));
  }

  if (web_page->url != url) {
    on_get_web_page_by_url(url, web_page_id, true);
  }

  promise.set_value(WebPageId(web_page_id));
}

void WebPagesManager::reload_web_page_by_url(const string &url, Promise<WebPageId> &&promise) {
  TRY_STATUS_PROMISE(promise, G()->close_status());
  td_->create_handler<GetWebPageQuery>(std::move(promise))->send(WebPageId(), url, 0);
}

SecretInputMedia WebPagesManager::get_secret_input_media(WebPageId web_page_id) const {
  if (!web_page_id.is_valid()) {
    return SecretInputMedia{};
  }

  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr) {
    return SecretInputMedia{};
  }
  return SecretInputMedia{nullptr, make_tl_object<secret_api::decryptedMessageMediaWebPage>(web_page->url)};
}

bool WebPagesManager::have_web_page(WebPageId web_page_id) const {
  if (!web_page_id.is_valid()) {
    return false;
  }
  return get_web_page(web_page_id) != nullptr;
}

tl_object_ptr<td_api::webPage> WebPagesManager::get_web_page_object(WebPageId web_page_id) const {
  if (!web_page_id.is_valid()) {
    return nullptr;
  }
  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr) {
    return nullptr;
  }
  int32 instant_view_version = [web_page] {
    if (web_page->instant_view.is_empty) {
      return 0;
    }
    if (web_page->instant_view.is_v2) {
      return 2;
    }
    return 1;
  }();

  FormattedText description;
  description.text = web_page->description;
  description.entities = find_entities(web_page->description, true, false);

  auto r_url = parse_url(web_page->display_url);
  if (r_url.is_ok()) {
    Slice host = r_url.ok().host_;
    if (!host.empty() && host.back() == '.') {
      host.truncate(host.size() - 1);
    }

    auto replace_entities = [](Slice text, vector<MessageEntity> &entities, auto replace_url) {
      int32 current_offset = 0;
      for (auto &entity : entities) {
        CHECK(entity.offset >= current_offset);
        text = utf8_utf16_substr(text, static_cast<size_t>(entity.offset - current_offset));
        auto entity_text = utf8_utf16_substr(text, 0, static_cast<size_t>(entity.length));
        text = text.substr(entity_text.size());
        current_offset = entity.offset + entity.length;

        auto replaced_url = replace_url(entity, entity_text);
        if (!replaced_url.empty()) {
          entity = MessageEntity(MessageEntity::Type::TextUrl, entity.offset, entity.length, std::move(replaced_url));
        }
      }
    };

    if (host == ""instagram.com"" || ends_with(host, "".instagram.com"")) {
      replace_entities(description.text, description.entities, [](const MessageEntity &entity, Slice text) {
        if (entity.type == MessageEntity::Type::Mention) {
          return PSTRING() << ""https://www.instagram.com/"" << text.substr(1) << '/';
        }
        if (entity.type == MessageEntity::Type::Hashtag) {
          return PSTRING() << ""https://www.instagram.com/explore/tags/"" << url_encode(text.substr(1)) << '/';
        }
        return string();
      });
    } else if (host == ""twitter.com"" || ends_with(host, "".twitter.com"")) {
      replace_entities(description.text, description.entities, [](const MessageEntity &entity, Slice text) {
        if (entity.type == MessageEntity::Type::Mention) {
          return PSTRING() << ""https://twitter.com/"" << text.substr(1);
        }
        if (entity.type == MessageEntity::Type::Hashtag) {
          return PSTRING() << ""https://twitter.com/hashtag/"" << url_encode(text.substr(1));
        }
        return string();
      });
    } else if (host == ""t.me"" || host == ""telegram.me"" || host == ""telegram.dog"" || host == ""telesco.pe"") {
      // leave everything as is
    } else {
      td::remove_if(description.entities,
                    [](const MessageEntity &entity) { return entity.type == MessageEntity::Type::Mention; });

      if (host == ""youtube.com"" || host == ""www.youtube.com"") {
        replace_entities(description.text, description.entities, [](const MessageEntity &entity, Slice text) {
          if (entity.type == MessageEntity::Type::Hashtag) {
            return PSTRING() << ""https://www.youtube.com/results?search_query="" << url_encode(text);
          }
          return string();
        });
      } else if (host == ""music.youtube.com"") {
        replace_entities(description.text, description.entities, [](const MessageEntity &entity, Slice text) {
          if (entity.type == MessageEntity::Type::Hashtag) {
            return PSTRING() << ""https://music.youtube.com/search?q="" << url_encode(text);
          }
          return string();
        });
      }
    }
  }

  auto duration = get_web_page_media_duration(web_page);
  return make_tl_object<td_api::webPage>(
      web_page->url, web_page->display_url, web_page->type, web_page->site_name, web_page->title,
      get_formatted_text_object(description, true, duration == 0 ? std::numeric_limits<int32>::max() : duration),
      get_photo_object(td_->file_manager_.get(), web_page->photo), web_page->embed_url, web_page->embed_type,
      web_page->embed_dimensions.width, web_page->embed_dimensions.height, web_page->duration, web_page->author,
      web_page->document.type == Document::Type::Animation
          ? td_->animations_manager_->get_animation_object(web_page->document.file_id)
          : nullptr,
      web_page->document.type == Document::Type::Audio
          ? td_->audios_manager_->get_audio_object(web_page->document.file_id)
          : nullptr,
      web_page->document.type == Document::Type::General
          ? td_->documents_manager_->get_document_object(web_page->document.file_id, PhotoFormat::Jpeg)
          : nullptr,
      web_page->document.type == Document::Type::Sticker
          ? td_->stickers_manager_->get_sticker_object(web_page->document.file_id)
          : nullptr,
      web_page->document.type == Document::Type::Video
          ? td_->videos_manager_->get_video_object(web_page->document.file_id)
          : nullptr,
      web_page->document.type == Document::Type::VideoNote
          ? td_->video_notes_manager_->get_video_note_object(web_page->document.file_id)
          : nullptr,
      web_page->document.type == Document::Type::VoiceNote
          ? td_->voice_notes_manager_->get_voice_note_object(web_page->document.file_id)
          : nullptr,
      instant_view_version);
}

tl_object_ptr<td_api::webPageInstantView> WebPagesManager::get_web_page_instant_view_object(
    WebPageId web_page_id) const {
  return get_web_page_instant_view_object(web_page_id, get_web_page_instant_view(web_page_id));
}

tl_object_ptr<td_api::webPageInstantView> WebPagesManager::get_web_page_instant_view_object(
    WebPageId web_page_id, const WebPageInstantView *web_page_instant_view) const {
  if (web_page_instant_view == nullptr) {
    return nullptr;
  }
  if (!web_page_instant_view->is_loaded) {
    LOG(ERROR) << ""Trying to get not loaded web page instant view"";
    return nullptr;
  }
  auto feedback_link =
      td_api::make_object<td_api::internalLinkTypeBotStart>(""previews"", PSTRING() << ""webpage"" << web_page_id.get());
  return td_api::make_object<td_api::webPageInstantView>(
      get_page_block_objects(web_page_instant_view->page_blocks, td_, web_page_instant_view->url),
      web_page_instant_view->view_count, web_page_instant_view->is_v2 ? 2 : 1, web_page_instant_view->is_rtl,
      web_page_instant_view->is_full, std::move(feedback_link));
}

void WebPagesManager::on_web_page_changed(WebPageId web_page_id, bool have_web_page) {
  LOG(INFO) << ""Updated "" << web_page_id;
  auto it = web_page_messages_.find(web_page_id);
  if (it != web_page_messages_.end()) {
    vector<FullMessageId> full_message_ids;
    for (const auto &full_message_id : it->second) {
      full_message_ids.push_back(full_message_id);
    }
    CHECK(!full_message_ids.empty());
    for (const auto &full_message_id : full_message_ids) {
      if (!have_web_page) {
        td_->messages_manager_->delete_pending_message_web_page(full_message_id);
      } else {
        td_->messages_manager_->on_external_update_message_content(full_message_id);
      }
    }
    if (have_web_page) {
      CHECK(web_page_messages_[web_page_id].size() == full_message_ids.size());
    } else {
      CHECK(web_page_messages_.count(web_page_id) == 0);
    }
  }
  auto get_it = pending_get_web_pages_.find(web_page_id);
  if (get_it != pending_get_web_pages_.end()) {
    auto requests = std::move(get_it->second);
    pending_get_web_pages_.erase(get_it);
    for (auto &request : requests) {
      on_get_web_page_preview_success(request.first, request.second.first, have_web_page ? web_page_id : WebPageId(),
                                      std::move(request.second.second));
    }
  }
  pending_web_pages_timeout_.cancel_timeout(web_page_id.get());
}

const WebPagesManager::WebPage *WebPagesManager::get_web_page(WebPageId web_page_id) const {
  auto p = web_pages_.find(web_page_id);
  if (p == web_pages_.end()) {
    return nullptr;
  } else {
    return p->second.get();
  }
}

const WebPagesManager::WebPageInstantView *WebPagesManager::get_web_page_instant_view(WebPageId web_page_id) const {
  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr || web_page->instant_view.is_empty) {
    return nullptr;
  }
  return &web_page->instant_view;
}

void WebPagesManager::on_pending_web_page_timeout_callback(void *web_pages_manager_ptr, int64 web_page_id_int) {
  if (G()->close_flag()) {
    return;
  }

  auto web_pages_manager = static_cast<WebPagesManager *>(web_pages_manager_ptr);
  send_closure_later(web_pages_manager->actor_id(web_pages_manager), &WebPagesManager::on_pending_web_page_timeout,
                     WebPageId(web_page_id_int));
}

void WebPagesManager::on_pending_web_page_timeout(WebPageId web_page_id) {
  if (G()->close_flag() || have_web_page(web_page_id)) {
    return;
  }

  int32 count = 0;
  auto it = web_page_messages_.find(web_page_id);
  if (it != web_page_messages_.end()) {
    vector<FullMessageId> full_message_ids;
    for (const auto &full_message_id : it->second) {
      if (full_message_id.get_dialog_id().get_type() != DialogType::SecretChat) {
        full_message_ids.push_back(full_message_id);
      }
      count++;
    }
    if (!full_message_ids.empty()) {
      send_closure_later(G()->messages_manager(), &MessagesManager::get_messages_from_server,
                         std::move(full_message_ids), Promise<Unit>(), ""on_pending_web_page_timeout"", nullptr);
    }
  }
  auto get_it = pending_get_web_pages_.find(web_page_id);
  if (get_it != pending_get_web_pages_.end()) {
    auto requests = std::move(get_it->second);
    pending_get_web_pages_.erase(get_it);
    for (auto &request : requests) {
      on_get_web_page_preview_fail(request.first, request.second.first, Status::Error(500, ""Request timeout exceeded""),
                                   std::move(request.second.second));
      count++;
    }
  }
  if (count == 0) {
    LOG(WARNING) << ""Have no messages and requests waiting for "" << web_page_id;
  }
}

void WebPagesManager::on_get_web_page_instant_view(WebPage *web_page, tl_object_ptr<telegram_api::page> &&page,
                                                   int32 hash, DialogId owner_dialog_id) {
  CHECK(page != nullptr);
  std::unordered_map<int64, Photo> photos;
  for (auto &photo_ptr : page->photos_) {
    Photo photo = get_photo(td_->file_manager_.get(), std::move(photo_ptr), owner_dialog_id);
    if (photo.is_empty() || photo.id.get() == 0) {
      LOG(ERROR) << ""Receive empty photo in web page instant view for "" << web_page->url;
    } else {
      auto photo_id = photo.id.get();
      photos.emplace(photo_id, std::move(photo));
    }
  }
  if (!web_page->photo.is_empty() && web_page->photo.id.get() != 0) {
    photos.emplace(web_page->photo.id.get(), web_page->photo);
  }

  std::unordered_map<int64, FileId> animations;
  std::unordered_map<int64, FileId> audios;
  std::unordered_map<int64, FileId> documents;
  std::unordered_map<int64, FileId> videos;
  std::unordered_map<int64, FileId> voice_notes;
  std::unordered_map<int64, FileId> others;
  auto get_map = [&](Document::Type document_type) {
    switch (document_type) {
      case Document::Type::Animation:
        return &animations;
      case Document::Type::Audio:
        return &audios;
      case Document::Type::General:
        return &documents;
      case Document::Type::Video:
        return &videos;
      case Document::Type::VoiceNote:
        return &voice_notes;
      default:
        return &others;
    }
  };

  for (auto &document_ptr : page->documents_) {
    if (document_ptr->get_id() == telegram_api::document::ID) {
      auto document = move_tl_object_as<telegram_api::document>(document_ptr);
      auto document_id = document->id_;
      auto parsed_document = td_->documents_manager_->on_get_document(std::move(document), owner_dialog_id);
      if (!parsed_document.empty()) {
        get_map(parsed_document.type)->emplace(document_id, parsed_document.file_id);
      }
    }
  }
  if (!others.empty()) {
    auto file_view = td_->file_manager_->get_file_view(others.begin()->second);
    LOG(ERROR) << ""Receive document of an unexpected type "" << file_view.get_type();
  }

  auto add_document = [&](const Document &document) {
    auto file_view = td_->file_manager_->get_file_view(document.file_id);
    if (file_view.has_remote_location()) {
      get_map(document.type)->emplace(file_view.remote_location().get_id(), document.file_id);
    } else {
      LOG(ERROR) << document.type << "" has no remote location"";
    }
  };
  if (!web_page->document.empty()) {
    add_document(web_page->document);
  }
  for (auto &document : web_page->documents) {
    add_document(document);
  }

  LOG(INFO) << ""Receive a web page instant view with "" << page->blocks_.size() << "" blocks, "" << animations.size()
            << "" animations, "" << audios.size() << "" audios, "" << documents.size() << "" documents, "" << photos.size()
            << "" photos, "" << videos.size() << "" videos and "" << voice_notes.size() << "" voice notes"";
  web_page->instant_view.page_blocks =
      get_web_page_blocks(td_, std::move(page->blocks_), animations, audios, documents, photos, videos, voice_notes);
  web_page->instant_view.view_count = (page->flags_ & telegram_api::page::VIEWS_MASK) != 0 ? page->views_ : 0;
  web_page->instant_view.is_v2 = page->v2_;
  web_page->instant_view.is_rtl = page->rtl_;
  web_page->instant_view.hash = hash;
  web_page->instant_view.url = std::move(page->url_);
  web_page->instant_view.is_empty = false;
  web_page->instant_view.is_full = !page->part_;
  web_page->instant_view.is_loaded = true;

  LOG(DEBUG) << ""Receive web page instant view: ""
             << to_string(get_web_page_instant_view_object(WebPageId(), &web_page->instant_view));
}

class WebPagesManager::WebPageLogEvent {
 public:
  WebPageId web_page_id;
  const WebPage *web_page_in;
  unique_ptr<WebPage> web_page_out;

  WebPageLogEvent() = default;

  WebPageLogEvent(WebPageId web_page_id, const WebPage *web_page) : web_page_id(web_page_id), web_page_in(web_page) {
  }

  template <class StorerT>
  void store(StorerT &storer) const {
    td::store(web_page_id, storer);
    td::store(*web_page_in, storer);
  }

  template <class ParserT>
  void parse(ParserT &parser) {
    td::parse(web_page_id, parser);
    td::parse(web_page_out, parser);
  }
};

void WebPagesManager::save_web_page(const WebPage *web_page, WebPageId web_page_id, bool from_binlog) {
  if (!G()->parameters().use_message_db) {
    return;
  }

  CHECK(web_page != nullptr);
  if (!from_binlog) {
    WebPageLogEvent log_event(web_page_id, web_page);
    auto storer = get_log_event_storer(log_event);
    if (web_page->log_event_id == 0) {
      web_page->log_event_id = binlog_add(G()->td_db()->get_binlog(), LogEvent::HandlerType::WebPages, storer);
    } else {
      binlog_rewrite(G()->td_db()->get_binlog(), web_page->log_event_id, LogEvent::HandlerType::WebPages, storer);
    }
  }

  LOG(INFO) << ""Save "" << web_page_id << "" to database"";
  G()->td_db()->get_sqlite_pmc()->set(
      get_web_page_database_key(web_page_id), log_event_store(*web_page).as_slice().str(),
      PromiseCreator::lambda([actor_id = actor_id(this), web_page_id](Result<> result) {
        send_closure(actor_id, &WebPagesManager::on_save_web_page_to_database, web_page_id, result.is_ok());
      }));
}

string WebPagesManager::get_web_page_url_database_key(const string &url) {
  return ""wpurl"" + url;
}

void WebPagesManager::on_binlog_web_page_event(BinlogEvent &&event) {
  if (!G()->parameters().use_message_db) {
    binlog_erase(G()->td_db()->get_binlog(), event.id_);
    return;
  }

  WebPageLogEvent log_event;
  log_event_parse(log_event, event.data_).ensure();

  auto web_page_id = log_event.web_page_id;
  LOG(INFO) << ""Add "" << web_page_id << "" from binlog"";
  auto web_page = std::move(log_event.web_page_out);
  CHECK(web_page != nullptr);

  web_page->log_event_id = event.id_;

  update_web_page(std::move(web_page), web_page_id, true, false);
}

string WebPagesManager::get_web_page_database_key(WebPageId web_page_id) {
  return PSTRING() << ""wp"" << web_page_id.get();
}

void WebPagesManager::on_save_web_page_to_database(WebPageId web_page_id, bool success) {
  if (G()->close_flag()) {
    return;
  }
  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr) {
    LOG(ERROR) << ""Can't find "" << (success ? ""saved "" : ""failed to save "") << web_page_id;
    return;
  }

  if (!success) {
    LOG(ERROR) << ""Failed to save "" << web_page_id << "" to database"";
    save_web_page(web_page, web_page_id, web_page->log_event_id != 0);
  } else {
    LOG(INFO) << ""Successfully saved "" << web_page_id << "" to database"";
    if (web_page->log_event_id != 0) {
      LOG(INFO) << ""Erase "" << web_page_id << "" from binlog"";
      binlog_erase(G()->td_db()->get_binlog(), web_page->log_event_id);
      web_page->log_event_id = 0;
    }
  }
}

void WebPagesManager::load_web_page_from_database(WebPageId web_page_id, Promise<Unit> promise) {
  if (!G()->parameters().use_message_db || loaded_from_database_web_pages_.count(web_page_id)) {
    promise.set_value(Unit());
    return;
  }

  LOG(INFO) << ""Load "" << web_page_id << "" from database"";
  auto &load_web_page_queries = load_web_page_from_database_queries_[web_page_id];
  load_web_page_queries.push_back(std::move(promise));
  if (load_web_page_queries.size() == 1u) {
    G()->td_db()->get_sqlite_pmc()->get(get_web_page_database_key(web_page_id),
                                        PromiseCreator::lambda([actor_id = actor_id(this), web_page_id](string value) {
                                          send_closure(actor_id, &WebPagesManager::on_load_web_page_from_database,
                                                       web_page_id, std::move(value));
                                        }));
  }
}

void WebPagesManager::on_load_web_page_from_database(WebPageId web_page_id, string value) {
  if (G()->close_flag()) {
    return;
  }
  if (!loaded_from_database_web_pages_.insert(web_page_id).second) {
    return;
  }

  auto it = load_web_page_from_database_queries_.find(web_page_id);
  vector<Promise<Unit>> promises;
  if (it != load_web_page_from_database_queries_.end()) {
    promises = std::move(it->second);
    CHECK(!promises.empty());
    load_web_page_from_database_queries_.erase(it);
  }

  LOG(INFO) << ""Successfully loaded "" << web_page_id << "" of size "" << value.size() << "" from database"";
  //  G()->td_db()->get_sqlite_pmc()->erase(get_web_page_database_key(web_page_id), Auto());
  //  value.clear();

  if (!have_web_page(web_page_id)) {
    if (!value.empty()) {
      auto result = make_unique<WebPage>();
      auto status = log_event_parse(*result, value);
      if (status.is_error()) {
        LOG(ERROR) << ""Failed to parse web page loaded from database: "" << status
                   << "", value = "" << format::as_hex_dump<4>(Slice(value));
      } else {
        update_web_page(std::move(result), web_page_id, true, true);
      }
    }
  } else {
    // web page has already been loaded from the server
  }

  for (auto &promise : promises) {
    promise.set_value(Unit());
  }
}

bool WebPagesManager::have_web_page_force(WebPageId web_page_id) {
  return get_web_page_force(web_page_id) != nullptr;
}

const WebPagesManager::WebPage *WebPagesManager::get_web_page_force(WebPageId web_page_id) {
  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page != nullptr) {
    return web_page;
  }
  if (!G()->parameters().use_message_db) {
    return nullptr;
  }
  if (loaded_from_database_web_pages_.count(web_page_id)) {
    return nullptr;
  }

  LOG(INFO) << ""Trying to load "" << web_page_id << "" from database"";
  on_load_web_page_from_database(web_page_id,
                                 G()->td_db()->get_sqlite_sync_pmc()->get(get_web_page_database_key(web_page_id)));
  return get_web_page(web_page_id);
}

FileSourceId WebPagesManager::get_web_page_file_source_id(WebPage *web_page) {
  if (!web_page->file_source_id.is_valid()) {
    web_page->file_source_id = td_->file_reference_manager_->create_web_page_file_source(web_page->url);
  }
  return web_page->file_source_id;
}

FileSourceId WebPagesManager::get_url_file_source_id(const string &url) {
  auto web_page_id = get_web_page_by_url(url);
  if (web_page_id.is_valid()) {
    const WebPage *web_page = get_web_page(web_page_id);
    if (web_page != nullptr) {
      if (!web_page->file_source_id.is_valid()) {
        web_pages_[web_page_id]->file_source_id =
            td_->file_reference_manager_->create_web_page_file_source(web_page->url);
      }
      return web_page->file_source_id;
    }
  }
  return url_to_file_source_id_[url] = td_->file_reference_manager_->create_web_page_file_source(url);
}

string WebPagesManager::get_web_page_search_text(WebPageId web_page_id) const {
  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr) {
    return """";
  }
  return PSTRING() << web_page->title + "" "" + web_page->description;
}

int32 WebPagesManager::get_web_page_media_duration(WebPageId web_page_id) const {
  const WebPage *web_page = get_web_page(web_page_id);
  if (web_page == nullptr) {
    return -1;
  }
  return get_web_page_media_duration(web_page);
}

int32 WebPagesManager::get_web_page_media_duration(const WebPage *web_page) {
  if (web_page->document.type == Document::Type::Audio || web_page->document.type == Document::Type::Video ||
      web_page->document.type == Document::Type::VideoNote || web_page->document.type == Document::Type::VoiceNote ||
      web_page->embed_type == ""iframe"") {
    return web_page->duration;
  }

  return -1;
}

vector<FileId> WebPagesManager::get_web_page_file_ids(const WebPage *web_page) const {
  if (web_page == nullptr) {
    return vector<FileId>();
  }

  vector<FileId> result = photo_get_file_ids(web_page->photo);
  if (!web_page->document.empty()) {
    web_page->document.append_file_ids(td_, result);
  }
  for (auto &document : web_page->documents) {
    document.append_file_ids(td_, result);
  }
  if (!web_page->instant_view.is_empty) {
    for (auto &page_block : web_page->instant_view.page_blocks) {
      page_block->append_file_ids(td_, result);
    }
  }
  return result;
}

}  // namespace td
",16234,True,3376.755820382812,median
"/***************************************************************************
 *   copyright            : (C) 2004 by Lukas Burget,UPGM,FIT,VUT,Brno     *
 *   email                : burget@fit.vutbr.cz                            *
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include ""BDTree.h""
#include ""Matrix.h""
#include ""common.h""
#include ""mymath.h""

#include <vector>
#include <iostream>
#include <ctime>


namespace STK
{

  // // virtual
  // void
  // Distribution::
  // Dump(std::ostream& rStream, const std::string& rPrefix) const
  // {
  // }
  
  // //***************************************************************************/
  // //***************************************************************************/
  // virtual
  void
  Distribution::
  DumpImplicit() const
  {
    Dump(std::cout, "" "");
  }
  
  // //***************************************************************************/
  // //***************************************************************************/
  // void
  // MapDistribution::
  // Dump(std::ostream& rStream, const std::string& rPrefix) const
  // {
  //   rStream << rPrefix;

  //   MapDistribution::Container::const_iterator i;
  //   for (i = mVec.begin(); i!=mVec.end(); ++i) {
  //     rStream << i->first << "": "" << i->second << ""\\t"";
  //   }
  //   rStream << std::endl;
  // }


  // //***************************************************************************/
  // //***************************************************************************/
  // const MapDistribution::ProbType
  // MapDistribution::
  // Entropy() const
  // {
  //   double e = 0;
  //   MapDistribution::Container::const_iterator i;

  //   for (i=mVec.begin(); i!=mVec.end(); ++i) {
  //     e -= i->second * log2(i->second);
  //   }
  //   
  //   return e;

  // }


  // //***************************************************************************/
  // //***************************************************************************/
  // const MapDistribution::ProbType
  // MapDistribution::
  // SplitEntropy(const MapDistribution& rD1, const MapDistribution& rD2)
  // {
  //   double w1 = rD1.mN / (rD1.mN + rD2.mN);
  //   double w2 = rD2.mN / (rD1.mN + rD2.mN);

  //   return w1*rD1.Entropy() + w2*rD2.Entropy();
  // }


  // //***************************************************************************/
  // //***************************************************************************/
  // void
  // MapDistribution::
  // ComputeFromCounts(const Data& rData)
  // {
  //   Data::const_iterator  i;
  //   MapDistribution::Container::iterator  j;
  //   double                n = 0;
  //     
  //   // set probs to 0
  //   for (j=mVec.begin(); j!=mVec.end(); ++j) {
  //     j->second = 0.0;
  //   }

  //   for (i=rData.begin(); i!=rData.end(); ++i) {
  //     n += *i;
  //   }

  //   for (i=rData.begin(), j=mVec.begin(); j!=mVec.end(); ++i, ++j) {
  //     j->second /= n;
  //   }
  // }


  // //***************************************************************************/
  // //***************************************************************************/
  // void
  // MapDistribution::
  // ComputeFromNGrams(const NGramSubset& rData)
  // {
  //   mVec.clear();
  //   mN = 0;

  //   // collect the counts
  //   NGramSubset::NGramContainer::const_iterator i;

  //   for (i=rData.mData.begin(); i!=rData.mData.end(); ++i) {
  //     NGram::TokenType* p_token = &((**i)[0]);
  //     NGram::ProbType   counts = (*i)->Counts();

  //     if (mVec.find(*p_token) == mVec.end()) {
  //       mVec[*p_token] = counts;
  //     }
  //     else {
  //       mVec[*p_token] += counts;
  //     }

  //     mN += counts;
  //   }
  //     
  //   // normalize counts to probs
  //   MapDistribution::Container::iterator  j;
  //   
  //   for (j=mVec.begin(); j!=mVec.end(); ++j) {
  //     j->second /= mN;
  //   }
  // }


  //***************************************************************************/
  //***************************************************************************/
  MapDistribution::ProbType
  MapDistribution::
  operator [] (const NGram::TokenType& rToken) const
  {
    assert (rToken < static_cast<int>(mVocabSize)); 

    Container::const_iterator i = mMap.find(rToken);
    if(i != mMap.end()) {
      return i->second;
    }
    else {
      return 0.0;
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  MapDistribution::ProbType&
  MapDistribution::
  operator [] (const NGram::TokenType& rToken)
  {
    assert (rToken < static_cast<int>(mVocabSize)); 
    return mMap[rToken];
  }


  // //***************************************************************************/
  // //***************************************************************************/
  // void
  // MapDistribution::
  // Smooth(const MapDistribution& rDistr, double r)
  // {
  //   MapDistribution::Container::iterator i_this;
  //   MapDistribution::Container::const_iterator i_parent;

  // } //Smooth(const MapDistribution& rDistr, double r)
  

  //***************************************************************************/
  //***************************************************************************/
  //***************************************************************************/
  //***************************************************************************/
  VecDistribution::
  VecDistribution(std::istream& rStream, BDTreeHeader& rHeader)
  {
    Read(rStream, rHeader);
  }


  //***************************************************************************/
  //***************************************************************************/
  VecDistribution*
  VecDistribution::
  Clone()
  {
    return new VecDistribution(*this);
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  Fix()
  {
    if (mN > 0) {
      double n=0.0;
      VecDistribution::Container::iterator i;

      for (i = mVec.begin(); i!=mVec.end(); ++i) {
        n += *i;
      }

      for (i = mVec.begin(); i!=mVec.end(); ++i) {
        *i /= n;
      }
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  Dump(std::ostream& rStream, const std::string& rPrefix) const
  {
    rStream << rPrefix << ""Data count: "" << mN << std::endl;
    rStream << rPrefix;

    VecDistribution::Container::const_iterator i;
    for (i = mVec.begin(); i!=mVec.end(); ++i) {
      rStream << *i << ""  "";
    }
    rStream << std::endl;
  }


  //***************************************************************************/
  //***************************************************************************/
  const VecDistribution::ProbType
  VecDistribution::
  Entropy() const
  {
    double e = 0;
    VecDistribution::Container::const_iterator i;

    for (i=mVec.begin(); i!=mVec.end(); ++i) {
      if (*i > 0) {
        e -= static_cast<double>(*i) * my_log(static_cast<double>(*i));
      }
    }
    
    return e;
  }


  //***************************************************************************/
  //***************************************************************************/
  const Distribution::ProbType
  Distribution::
  SplitEntropy(const Distribution& rD1, const Distribution& rD2)
  {
    double w1 = rD1.mN / (rD1.mN + rD2.mN);
    double w2 = rD2.mN / (rD1.mN + rD2.mN);

    return w1*rD1.Entropy() + w2*rD2.Entropy();
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  ComputeFromNGramSubsets(const NGramSubsets& rSubsets)
  {
    NGramSubsets::const_iterator i_subset;
    Container::iterator j;
    double mass = 0.0;
      
    // set probs to 0
    for (j=mVec.begin(); j!=mVec.end(); ++j) {
      *j = 0.0;
    }

    for (i_subset=rSubsets.begin(); i_subset!=rSubsets.end(); ++i_subset) {
      NGramSubset::NGramContainer::const_iterator i_ngram;

      // accumulate each dist and sum overal data mass
      for (i_ngram=i_subset->mData.begin(); 
           i_ngram!=i_subset->mData.end(); 
           ++i_ngram) 
      {
        NGram::TokenType* p_token = &((**i_ngram)[0]);
        NGram::ProbType   counts = (*i_ngram)->Counts();

        mVec[*p_token] += counts;
        mass           += counts;
      }
    }

    // normalize
    for (j=mVec.begin(); j!=mVec.end(); ++j) {
      *j = *j / mass;
    }

    mN = mass;
  }


  //***************************************************************************/
  //***************************************************************************/
  VecDistribution::ProbType 
  VecDistribution::
  operator [] (const NGram::TokenType& rToken) const
  {
    assert (rToken < static_cast<int>(mVec.size()));
    return mVec[rToken];
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  Merge(const Distribution& rDistr)
  {
    const VecDistribution* p_distr = dynamic_cast<const VecDistribution*>(&rDistr);

    double norm = 0.0;
    VecDistribution::Container::iterator i_this = mVec.begin();
    VecDistribution::Container::const_iterator i_parent = p_distr->mVec.begin();

    assert(mVec.size() == p_distr->mVec.size());

    while (i_this != mVec.end()) {
      *i_this = mN * (*i_this) + p_distr->mN * (*i_parent);
      norm += *i_this;

      ++i_this;
      ++i_parent;
    } // while (i_this != mVec.end()) {

    // normalize
    if (norm > 0) {
      for (i_this = mVec.begin(); i_this != mVec.end(); ++i_this) {
        *i_this /= norm;
      }
    }

    mN += p_distr->mN;
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  Reset() 
  {
    VecDistribution::Container::iterator i_this;

    for (i_this = mVec.begin(); i_this != mVec.end(); ++i_this) {
      *i_this = 0.0;
    }

    mN = 0.0;
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  Smooth(const Distribution& rDistr, FLOAT r)
  {
    const VecDistribution* p_distr = dynamic_cast<const VecDistribution*>(&rDistr);

    double norm   = 0; //DBL_EPSILON;
    double new_mn = 0; //DBL_EPSILON;
    VecDistribution::Container::iterator        i_this   = mVec.begin();
    VecDistribution::Container::const_iterator  i_parent = p_distr->mVec.begin();

    assert(mVec.size() == p_distr->mVec.size());

    while (i_this != mVec.end()) {
      // compute weight
      double b =  *i_this*mN / (*i_this*mN + r) ;

      *i_this = b * (*i_this) + (1-b) * (*i_parent);
      norm    += *i_this;
      new_mn  += b * (*i_this * mN) + (1-b) * (*i_parent * p_distr->mN);

      ++i_this;
      ++i_parent;
    } // while (i_this != mVec.end() && i_parent != p_distr->mVec.end()) {

    if (norm > 0) {
      // normalize
      for (i_this = mVec.begin(); i_this != mVec.end(); ++i_this) {
        *i_this /= norm;
      }
    }
    //mN = new_mn;
  } //Smooth(const VecDistribution& rDistr, double r)
  

  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  Interpolate(const Distribution& rDistr, FLOAT r)
  {
    double norm   = 0; //DBL_EPSILON;
    //double new_mn = 0; //DBL_EPSILON;
    size_t i = 0;

    assert(this->Size() == rDistr.Size());

    for (i = 0; i<mVec.size(); i++) {
      (*this)[i] = r * (*this)[i] + (1-r) * rDistr[i];
      norm    += (*this)[i];

      i++;
    } // while (i_this != mVec.end() && i_parent != rDistr.mVec.end()) {

    if (norm > 0) {
      // normalize
      for (i = 0; i<mVec.size(); i++) {
        (*this)[i] /= norm;
      }
    }
    //mN = new_mn;
  } //Smooth(const VecDistribution& rDistr, double r)
  

  //***************************************************************************/
  //***************************************************************************/
  void
  VecDistribution::
  MapAdapt(const Distribution& rDistr, FLOAT r)
  {
    const VecDistribution* p_distr = dynamic_cast<const VecDistribution*>(&rDistr);

    double norm   = 0; //DBL_EPSILON;
    //double new_mn = 0; //DBL_EPSILON;
    VecDistribution::Container::iterator        i_this   = mVec.begin();
    VecDistribution::Container::const_iterator  i_parent = p_distr->mVec.begin();

    assert(mVec.size() == p_distr->mVec.size());

    while (i_this != mVec.end()) {
      // compute weight
      double b =  mN / (mN + r) ;

      *i_this = b * (*i_this) + (1-b) * (*i_parent);
      norm    += *i_this;

      ++i_this;
      ++i_parent;
    } // while (i_this != mVec.end() && i_parent != p_distr->mVec.end()) {

    if (norm > 0) {
      // normalize
      for (i_this = mVec.begin(); i_this != mVec.end(); ++i_this) {
        *i_this /= norm;
      }
    }
  } //MapAdapt(const VecDistribution& rDistr, double r)
  

  //***************************************************************************/
  //***************************************************************************/
  //***************************************************************************/
  //***************************************************************************/
  BDTree::
  BDTree(NGramSubsets& rData, NGramSubsets* rHeldoutData, BDTreeBuildTraits& rTraits,
      BDTree* pParent, const std::string& rPrefix)
  : mpDist(NULL), mpBackoffDist(NULL)
  {
    BuildFromNGrams(rData, rHeldoutData, rTraits, pParent, rPrefix);
  }

  //***************************************************************************/
  //***************************************************************************/
  BDTree::
  BDTree(const BDTree& rOrig)
  {
    if (!rOrig.IsLeaf()) {
      mpDist      = NULL;
      mpTree0     = rOrig.mpTree0->Clone();
      mpTree1     = rOrig.mpTree1->Clone();
      mpQuestion  = rOrig.mpQuestion->Clone();
    }
    else {
      //mpDist      = new VecDistribution(*(rOrig.mpDist));
      mpDist      = rOrig.mpDist->Clone();
      mpTree0     = NULL;
      mpTree1     = NULL;
      mpQuestion  = NULL;
    }
    
    if (NULL == rOrig.mpBackoffDist) {
      mpBackoffDist = NULL;
    }
    else {
      //mpBackoffDist = new VecDistribution(*(rOrig.mpBackoffDist));
      mpBackoffDist = rOrig.mpBackoffDist->Clone();
    }
  }

  //***************************************************************************/
  //***************************************************************************/
  BDTree::
  BDTree(std::istream& rStream, BDTreeHeader& rHeader)
  : mpDist(NULL), mpBackoffDist(NULL)
  {
    Read(rStream, rHeader);
  }


  //***************************************************************************/
  //***************************************************************************/
  BDTree::
  ~BDTree()
  {
    if (NULL != mpTree0) {
      delete mpTree0;
    }
    if (NULL != mpTree1) {
      delete mpTree1;
    }
    if (NULL != mpQuestion) {
      delete mpQuestion;
    }
    if (NULL != mpDist) {
      delete mpDist;
    }
    if (NULL != mpBackoffDist) {
      delete mpBackoffDist;
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  BuildFromNGrams(NGramSubsets& rNGrams, NGramSubsets* rHeldoutNGrams, BDTreeBuildTraits& rTraits,
      BDTree* pParent, const std::string& rPrefix)
  {
    FLOAT     total_entropy, heldout_total_entropy;
    FLOAT     split_entropy, heldout_split_entropy;
    FLOAT     entropy_red, heldout_entropy_red;

    FLOAT     total_mmi;
    FLOAT     split_mmi;
    FLOAT     mmi_inc;
    BSetQuestion* p_new_question = NULL;
    int       depth = rTraits.mCurDepth;
    size_t    vocab_size = rNGrams[0].Parent().pTargetTable()->Size();



    if (NULL != pParent && rTraits.mSmoothR > 0) {
      // compute distribution as we  want to smooth right away, for
      // which we need the parent distribution
      if (rTraits.mUseMapDistribution) {
        //mpDist = new MapDistribution(vocab_size);
      }
      else {
        mpDist = new VecDistribution(vocab_size);
      }
      mpDist->ComputeFromNGramSubsets(rNGrams);
      mpDist->Smooth(*(pParent->mpDist), rTraits.mSmoothR);
    }

    if (rTraits.mVerbosity > 0) {
      std::cout << ""BDTree::Info      "" << rPrefix << ""Data mass: "" << rNGrams.Mass() << std::endl;
      std::cout << ""BDTree::Info      "" << rPrefix << ""Token count: "" << rNGrams.TokenCount() << std::endl;
      std::cout << ""BDTree::Info      "" << rPrefix << ""Depth:     "" << depth << std::endl;
    }

    // check for max depth criterion
    if (rTraits.mMaxDepth <= rTraits.mCurDepth) {
      if (rTraits.mVerbosity > 0) {
        std::cout << ""BDTree::Info      "" << rPrefix << ""Leaf due to maximum depth criterion"" << std::endl;
      }

      if (NULL == mpDist) {
        mpDist = new VecDistribution(vocab_size);
        mpDist->ComputeFromNGramSubsets(rNGrams);
      }
      mpQuestion = NULL;
      mpTree0    = NULL;
      mpTree1    = NULL;
      return;
    }

    // check for data sufficiency
    if (rNGrams.Mass() < rTraits.mMinInData) {
      if (rTraits.mVerbosity > 0) {
        std::cout << ""BDTree::Info      "" << rPrefix << ""Leaf due to minimum input data criterion"" << std::endl;
      }

      if (NULL == mpDist) {
        mpDist = new VecDistribution(vocab_size);
        mpDist->ComputeFromNGramSubsets(rNGrams);
      }
      mpQuestion = NULL;
      mpTree0    = NULL;
      mpTree1    = NULL;
      return;
    }

    if (rTraits.mMMItoggle) {
      // compute mmi
      total_mmi       = rNGrams.MMI(rTraits.mMMIEta);
      p_new_question  = FindSimpleQuestion_MMI(rNGrams, rTraits, &split_mmi);
      mmi_inc         = split_mmi - total_mmi;

      if (NULL != p_new_question) {
        p_new_question->Dump(std::cout, std::string(""BDTree::Info      "")+rPrefix);
        // compute entropy
        total_entropy = rNGrams.ParallelEntropy();
        split_entropy = rNGrams.ParallelSplitEntropy(*p_new_question, NULL, NULL);
        
        entropy_red   = total_entropy - split_entropy;

        std::cout << ""BDTree::Info      "" << rPrefix << ""Data Entropy:      "" << total_entropy << std::endl;
        std::cout << ""BDTree::Info      "" << rPrefix << ""Split Entropy:     "" << split_entropy << std::endl;
        std::cout << ""BDTree::Info      "" << rPrefix << ""Entropy reduction: "" << entropy_red << std::endl;
        std::cout << ""BDTree::Info      "" << rPrefix << ""Data MMI:           "" << total_mmi << std::endl;
        std::cout << ""BDTree::Info      "" << rPrefix << ""Data split MMI:     "" << split_mmi << std::endl;
        std::cout << ""BDTree::Info      "" << rPrefix << ""MMI Increase:       "" << mmi_inc << std::endl;

        if (isnan(entropy_red)) {
          throw std::runtime_error(""Entropy is unexpectedly NaN"");
        }
      }

      if (rTraits.mVerbosity > 0) {
      }
    }
    else {
      // compute entropy
      total_entropy = rNGrams.ParallelEntropy();

      if(total_entropy > 0)
      {
        // find best predictor and return split entropy
        p_new_question = FindSimpleQuestion(rNGrams, rTraits, &split_entropy);

        if(rHeldoutNGrams != NULL)
        {
	  double mass0, mass1;
          // compute heldout entropy before split
          heldout_total_entropy = rHeldoutNGrams->ParallelEntropy();
	  heldout_split_entropy = rHeldoutNGrams->ParallelSplitEntropy(*p_new_question, &mass0, &mass1);
	  heldout_entropy_red   = heldout_total_entropy - heldout_split_entropy;
        }

        entropy_red = total_entropy - split_entropy;
      }
      else
      {
        total_entropy = 0;
        entropy_red = 0; 
      }


      if (rTraits.mVerbosity > 0) {
        if (entropy_red == 0) {
          std::cout << ""BDTree::Info      "" << rPrefix << ""No predictor found "" << std:: endl;
          std::cout << ""BDTree::Info      "" << rPrefix << ""Data Entropy:      "" << total_entropy << std::endl;
        }
        else {
	  if(rTraits.mLVCSR)
	    std::cout << ""BDTree::Info      "" << rPrefix << ""Predictor:      "" << p_new_question->Predictor()<< std::endl;	    
	  else
	    p_new_question->Dump(std::cout, std::string(""BDTree::Info      "")+rPrefix);

          std::cout << ""BDTree::Info      "" << rPrefix << ""Data Entropy:      "" << total_entropy << std::endl;
          std::cout << ""BDTree::Info      "" << rPrefix << ""Split Entropy:     "" << split_entropy << std::endl;
          std::cout << ""BDTree::Info      "" << rPrefix << ""Entropy reduction: "" << entropy_red << std::endl;
	  if(rHeldoutNGrams != NULL)
	    std::cout << ""BDTree::Info      "" << rPrefix << ""Heldout entropy reduction: "" << heldout_entropy_red << std::endl;
        }
      }
    }

    if (rTraits.mMMItoggle && mmi_inc < rTraits.mMinMMIIncrease) {
      if (rTraits.mVerbosity > 0) {
        std::cout << ""BDTree::Info      "" << rPrefix << ""Leaf due to minimum MMI increase criterion"" << std::endl;
      }

      if (NULL != p_new_question) {
        delete p_new_question;
      }

      if (NULL == mpDist) {
        mpDist = new VecDistribution(vocab_size);
        mpDist->ComputeFromNGramSubsets(rNGrams);
      }
      mpQuestion = NULL;
      mpTree0    = NULL;
      mpTree1    = NULL;
    }
    else if (entropy_red == 0
      || (rHeldoutNGrams != NULL && heldout_entropy_red <= 0) 
      || (rHeldoutNGrams == NULL && entropy_red < rTraits.mMinReduction)) 
    {
      if (rTraits.mVerbosity > 0) 
      {
	if(rHeldoutNGrams != NULL)
	  std::cout << ""BDTree::Info      "" << rPrefix << ""Leaf due to heldout data entropy reduction criterion"" << std::endl;
	else
	  std::cout << ""BDTree::Info      "" << rPrefix << ""Leaf due to minimum entropy reduction criterion"" << std::endl;
      }

      if (NULL != p_new_question) {
        delete p_new_question;
      }

      if (NULL == mpDist) {
        mpDist = new VecDistribution(vocab_size);
        mpDist->ComputeFromNGramSubsets(rNGrams);
      }
      mpQuestion = NULL;
      mpTree0    = NULL;
      mpTree1    = NULL;
    }
    // if entropy reduction && MI increase still big enough, build each subtree
    else {
      NGramSubsets* p_split_data0 = new NGramSubsets;
      NGramSubsets* p_split_data1 = new NGramSubsets;

      mpQuestion  = p_new_question;
      rNGrams.Split(*mpQuestion, *p_split_data0, *p_split_data1);

      NGramSubsets* p_split_hld_data0 = NULL;
      NGramSubsets* p_split_hld_data1 = NULL;
      if(rHeldoutNGrams != NULL)
      {
        p_split_hld_data0 = new NGramSubsets;
        p_split_hld_data1 = new NGramSubsets;
        rHeldoutNGrams->Split(*mpQuestion, *p_split_hld_data0, *p_split_hld_data1);
      }


      rTraits.mCurDepth = depth + 1;
      mpTree0     = new BDTree(*p_split_data0, p_split_hld_data0, rTraits, this, rPrefix + ""-  "");
      rTraits.mCurDepth = depth + 1;
      mpTree1     = new BDTree(*p_split_data1, p_split_hld_data1, rTraits, this, rPrefix + ""+  "");

      delete p_split_data0;
      delete p_split_data1;

      delete p_split_hld_data0;
      delete p_split_hld_data1;

      if (NULL != mpDist) {
        delete mpDist;
        mpDist = NULL;
      }
    } // else declare leaf
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  GetInfo(BDTreeInfo& rInfo, const BDTree* pParent) const
  {
    rInfo.mTotalNodes++;

    if (!IsLeaf()) {
      mpTree0->GetInfo(rInfo, this);
      mpTree1->GetInfo(rInfo, this);

      if (NULL == pParent) {
        rInfo.mAverageEntropy /= rInfo.mTotalData;
      }
    }
    else {
      rInfo.mTotalLeaves++;
      rInfo.mTotalData += mpDist->Counts();
      rInfo.mAverageEntropy += mpDist->Counts() * mpDist->Entropy();
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  BSetQuestion*
  BDTree::
  FindSimpleQuestion(NGramSubsets& rNGrams, BDTreeBuildTraits& rTraits, FLOAT* pSplitEnt) 
  {
    FLOAT           e = 0.0;
    FLOAT           best_e = -1.0;
    BSetQuestion*   p_best_question = NULL;

    // choose predictor randomly for a random tree
    if(rTraits.mRandomizeTree && rTraits.mLVCSR)
    {
      int rand_pred;
      srand((unsigned)time(0));


      // In case --morphpred=70 or anything, the value means that we keep those best predictors performing better that percentage to the best one
      // and then randomly choose between them
      if(rTraits.mMorphologicalPredictors > 1)
      {
        double* e_array = new double[rTraits.mOrder];
        int i, counter = 0;
        // go through all predictors and find subset
        for (i=1; i<rTraits.mOrder; ++i) 
        {
          BSetQuestion* p_tmp_question = FindSubset_Greedy(rNGrams, rTraits, &e, i);
          e_array[i-1] = e;
          delete p_tmp_question;
        }
        double min_e, max_e, limit;
        min_e = e_array[0];
        max_e = e_array[0];
        for(i = 0; i < rTraits.mOrder-1; i++)
	{
          if(e_array[i] > max_e)
            max_e = e_array[i];
          else if(e_array[i] < min_e)
            min_e = e_array[i];
        }
        // We're interested in lower entropy, that's why we do 100 - rTraits.mMorphologicalPredictors and then take everything that's lower
        limit = (max_e - min_e) * (100 - rTraits.mMorphologicalPredictors) / 100 + min_e;
        int preds_below_limit = 0;
        for(i = 0; i < rTraits.mOrder-1; i++)
          if(e_array[i] <= limit)
            preds_below_limit++;

        // Now random value is in [1, preds_above_limit+1)
        rand_pred = (int) ( ( (double)rand() / (  (double)(RAND_MAX) + (double)(1) ) ) * preds_below_limit ) + 1;
        for(i = 0; i < rTraits.mOrder-1; i++)
        {
          if(e_array[i] <= limit)
            counter++;
          if(counter == rand_pred)
	  {
            p_best_question = FindSubset_Greedy(rNGrams, rTraits, &e, i+1);
            best_e = e;
            break;
          }
	}
        delete e_array;
      }
      // In case of morph trees with --morphpred=1 , we do always keep word-questions in random shuffle and choose one additional predictor randomly
      else if(rTraits.mMorphologicalPredictors)
      {
        rand_pred = (int) ( ( (double)rand() / (  (double)(RAND_MAX) + (double)(1) ) ) * (rTraits.mOrder-1) ) + 1;

        std::string factor_type, wrd;
        NGram::TokenType ngram_token;
        NGramSubset::NGramContainer::const_iterator it;

        // go through all predictors and find subset
        for (int i=1; i<rTraits.mOrder; ++i) 
        {
          it = rNGrams[0].mData.begin();
          ngram_token = (**it)[i];
          factor_type = rNGrams[0].Parent().pPredictorTable()->IToA(ngram_token);
          if(i == rand_pred || factor_type[0] == 'W')
	  {
            BSetQuestion* p_tmp_question = FindSubset_Greedy(rNGrams, rTraits, &e, i);

            if (e < best_e || best_e < 0) {
              if (NULL != p_best_question) {
                delete p_best_question;
              }
              best_e = e;
              p_best_question = p_tmp_question;
            }
	  } 
        }
      }
      else
      {
        rand_pred = (int) ( ( (double)rand() / (  (double)(RAND_MAX) + (double)(1) ) ) * (rTraits.mOrder-1) ) + 1;
        BSetQuestion* p_tmp_question = FindSubset_Greedy(rNGrams, rTraits, &e, rand_pred);

        if (e < best_e || best_e < 0) {
          if (NULL != p_best_question) {
            delete p_best_question;
          }
          best_e = e;
          p_best_question = p_tmp_question;
        } 
      }
    }
    else if(rTraits.mRandomizePredictors) {
      int rand_pred = (int) (((double)rand() / ((double)(RAND_MAX) + 
              (double)(1.0))) * (rTraits.mOrder - 1)) + 1;

      p_best_question = FindSubset_Greedy(rNGrams, rTraits, &best_e, rand_pred);
    }
    else
    {
      // go through all predictors and find subset
      for (int i=1; i<rTraits.mOrder; ++i) {
        BSetQuestion* p_tmp_question = FindSubset_Greedy(rNGrams, rTraits, &e, i);

        if (e < best_e || best_e < 0) {
          if (NULL != p_best_question) {
            delete p_best_question;
          }
          best_e = e;
          p_best_question = p_tmp_question;
        } 
      }
    }

    if (NULL != pSplitEnt ) {
      *pSplitEnt = best_e;
    }

    return p_best_question;
  }


  //***************************************************************************/
  //***************************************************************************/
  BSetQuestion*
  BDTree::
  FindSimpleQuestion_MMI(NGramSubsets& rNGrams, BDTreeBuildTraits& rTraits, FLOAT* pSplitMMI) 
  {
    FLOAT           mmi = -10000;
    FLOAT           best_mmi = mmi - 1.0;
    BSetQuestion*   p_best_question = NULL;


    // go through all predictors and find subset
    for (int i=1; i<rTraits.mOrder; ++i) {
      BSetQuestion* p_tmp_question = FindSubset_Greedy_MMI(rNGrams, rTraits, &mmi, i);

      if (mmi > best_mmi) {
        if (NULL != p_best_question) {
          delete p_best_question;
        }
        best_mmi = mmi;
        p_best_question = p_tmp_question;
      } 
    }

    if (NULL != pSplitMMI ) {
      *pSplitMMI = best_mmi;
    }

    return p_best_question;
  }


  //***************************************************************************/
  //***************************************************************************/
  BSetQuestion*
  BDTree::
  FindSubset_Greedy(NGramSubsets& rNGrams, BDTreeBuildTraits& rTraits, FLOAT* pSplitEnt,
      int pred) 
  {
    bool    inserted  = true;
    bool    deleted   = true;
    double  e         = rNGrams.ParallelEntropy();
    double  this_e, this_log_likelihood; // log_likelihood
    double  mass0, mass1;

    //int     vocab_size = rNGrams[0].Parent().pTargetTable()->Size();
    int     target_vocab_size = rNGrams[0].Parent().pTargetTable()->Size();
    int     vocab_size = rNGrams[0].Parent().pPredictorTable()->Size();

    int     i_vocab, vocab_start, vocab_end;
    int     i_best_change;
    int     node_vocab_size;
    BSetQuestion* p_new_question = new BSetQuestion(pred, vocab_size);
    
    // It's not only this - we also implement Exchange algorithm there for finding the best question (as described in Peng Xu thesis)
    // It should be pretty fast. Implemented only for trigrams
    if(rTraits.mLVCSR && rTraits.mOrder >= 3)
    {
      NGramSubsets::const_iterator        i_subset;

      // NB!!! if vocab_size and node_vocab_size are different (we reduce the matrices somehow), some things must be changed in the below code
      
      // Wwe detect wich kinf of predictor we deal with and find corresponding vocabulary subset
      if(rTraits.mMorphologicalPredictors)
      {
	MorphVocabSection VocabSection(rNGrams, pred);
	node_vocab_size =  VocabSection.Size();
	vocab_start = VocabSection.FirstElem();
	vocab_end = VocabSection.LastElem();
      }
      else
      {
	node_vocab_size = vocab_size;
	vocab_start = 0;
	vocab_end = vocab_size-1;
      }

      srand((unsigned)time(0));

      // make initial rundom shuffle of the question set if it's a random tree
      if(rTraits.mRandomizeTree)
        for(i_vocab = vocab_start; i_vocab <= vocab_end; ++i_vocab)
          p_new_question->RandomShuffle(i_vocab);

      // construct helper ""sparce"" matrix
      SparseBigramMatrix BigramMatrix0(target_vocab_size, vocab_size), BigramMatrix1(target_vocab_size, vocab_size);

      // first iterate over ngrams and count, how many units do we have in each row (corresponding to predictor) and allocate memory

      // collect counts for each language and overal count for all langs
      for (i_subset=rNGrams.begin(); i_subset!=rNGrams.end(); ++i_subset) 
      {
        //std::cout << i_subset->Mass() << std::endl;
	BigramMatrix0.CreateSizeVector(*i_subset, *p_new_question, pred, false);
	BigramMatrix1.CreateSizeVector(*i_subset, *p_new_question, pred, true);

	BigramMatrix0.AllocateMem();
	BigramMatrix1.AllocateMem();

	BigramMatrix0.Fill(*i_subset, *p_new_question, pred, false);
	BigramMatrix1.Fill(*i_subset, *p_new_question, pred, true);

        // Ondra asks: I don't understand this line, log_likelihood is not used any longer
        // Why do we have to compute this???
	//log_likelihood = BigramMatrix0.CountLogLikelihood(BigramMatrix1);
      }

      int i_predictor;
      // If we randomly put a 1 for some predictior, but there is no data for it at all - switch it to 0
      for(i_predictor = vocab_start; i_predictor <= vocab_end; ++i_predictor)
      {
	if(p_new_question->EvalRawToken(i_predictor)
            && !BigramMatrix0.GetSizeVectorCell(i_predictor) && !BigramMatrix1.GetSizeVectorCell(i_predictor))
          p_new_question->Unset(i_predictor);
      }


      // Move elements from one set to another to find the best question (Exchange algorithm)
      //double this_e = rNGrams.ParallelSplitEntropy(*p_new_question, &mass0, &mass1);
      
      while (inserted || deleted) 
      {
	inserted      = false;
	deleted       = false;

	// move from A_ to A (insertion) - we try to insert as many as possible
	for(i_predictor = vocab_start; i_predictor <= vocab_end; ++i_predictor) // NB!!! if vocab_size and node_vocab_size are different (we reduce the matrices somehow), then there things must be changed 
	{
	  if (!p_new_question->EvalRawToken(i_predictor) && BigramMatrix0.GetSizeVectorCell(i_predictor)) 
	  {
	    p_new_question->Set(i_predictor);

	    this_log_likelihood = BigramMatrix1.InsertBasicElement(BigramMatrix0, i_predictor);
	    
	    // now we get log-likelihood. We can either maximize this or minimize entropy. The switch to entropy is:
	    mass0 = BigramMatrix0.GetTotalCountSum();
	    mass1 = BigramMatrix1.GetTotalCountSum();
	    this_e = -this_log_likelihood  / (mass0 + mass1);

	    // Let the question be inserted and save changes - i.e. matrices are modified after each insertion
	    if (this_e > 0 && this_e < e && mass0 >= rTraits.mMinInData && mass1 >= rTraits.mMinInData) 
	    {
	      e = this_e;
	      inserted = true;
	    }
	    // If reduction is insignificant, cancel the insertion - i.e. modify back the matrices
	    else
	    {
	      p_new_question->Unset(i_predictor);
	      BigramMatrix0.InsertBasicElement(BigramMatrix1, i_predictor);
	    }
	  }
	}

	// move from A to A_ (deletion) - we try to delete as many as possible
	for(i_predictor = vocab_start; i_predictor < vocab_end; ++i_predictor) // NB!!! if vocab_size and node_vocab_size are different (we reduce the matrices somehow), then there things must be changed 
	{
	  if (p_new_question->EvalRawToken(i_predictor) && BigramMatrix1.GetSizeVectorCell(i_predictor)) 
	  {
	    p_new_question->Unset(i_predictor);

	    this_log_likelihood = BigramMatrix0.InsertBasicElement(BigramMatrix1, i_predictor);
	    
	    // now we get log-likelihood. We can either maximize this or minimize entropy. The switch to entropy is:
	    mass0 = BigramMatrix0.GetTotalCountSum();
	    mass1 = BigramMatrix1.GetTotalCountSum();
	    this_e = -this_log_likelihood  / (mass0 + mass1);

	    // Let the question be inserted and save changes - i.e. matrices are modified after each insertion
	    if (this_e > 0 && this_e < e && mass0 >= rTraits.mMinInData && mass1 >= rTraits.mMinInData) 
	    {
	      e = this_e;
	      deleted = true;
	    }
	    // If reduction is insignificant, cancel the insertion - i.e. modify back the matrices
	    else
	    {
	      p_new_question->Set(i_predictor);
	      BigramMatrix1.InsertBasicElement(BigramMatrix0, i_predictor);
	    }
	  }
	}
      }
    }
    else
    {
      if (rTraits.mRandomizeQuestions) {
        BSetQuestion  aux_question(pred, vocab_size);
        double        aux_mass_set;
        double        aux_mass_unset = rNGrams.Mass();

        for(i_vocab = 0; i_vocab <= vocab_size; ++i_vocab) {
          // probe the question. Does it do any data split???? ...
          aux_question.Set(i_vocab);
          rNGrams.ParallelSplitEntropy(aux_question, &aux_mass_set, &mass0);
          aux_question.Unset(i_vocab);
          
          // ... if yes, then randomize it
          if (aux_mass_set != aux_mass_unset) {
            p_new_question->RandomShuffle(i_vocab);
          }
        }
      }

      // continue probing if any change was made in the previous iteration
      while (inserted || deleted) {
        inserted      = false;
        deleted       = false;

        // probe insertions
        for (i_vocab=0; i_vocab<vocab_size; ++i_vocab) {
          if (!p_new_question->EvalRawToken(i_vocab)) {
            p_new_question->Set(i_vocab);

            double this_e = rNGrams.ParallelSplitEntropy(*p_new_question, &mass0, &mass1);

            if (this_e > 0 && this_e < e && mass0 >= rTraits.mMinInData && 
                mass1 >= rTraits.mMinInData) 
            {
              e             = this_e;
              i_best_change = i_vocab;
              inserted      = true;
            }

            p_new_question->Unset(i_vocab);
          }
        }

        // commit insertion
        if (inserted) {
          p_new_question->Set(i_best_change);
        }

        // probe deletions
        for (i_vocab=0; i_vocab < vocab_size; ++i_vocab) {
          // only inspect positive questions
          if (p_new_question->EvalRawToken(i_vocab)) {
            p_new_question->Unset(i_vocab);

            double this_e = rNGrams.ParallelSplitEntropy(*p_new_question, &mass0, &mass1);


            if (this_e > 0 && this_e < e && mass0 >= rTraits.mMinInData && 
                mass1 >= rTraits.mMinInData) 
            {
              e             = this_e;
              i_best_change = i_vocab;
              deleted       = true;
            }

            p_new_question->Set(i_vocab);
          }
        }

        // commit deletion
        if (deleted) {
          p_new_question->Unset(i_best_change);
        }
      }
    }

    // update entropy if possible
    if (NULL != pSplitEnt) {
      *pSplitEnt = e;
    }

    return p_new_question;
  }


  //***************************************************************************/
  //***************************************************************************/
  BSetQuestion*
  BDTree::
  FindSubset_Greedy_MMI(NGramSubsets& rNGrams, BDTreeBuildTraits& rTraits, 
      FLOAT* pSplitMMI, int pred) 
  {
    double  mass0;
    double  mass1;
    bool    inserted  = true;
    bool    deleted   = true;
    double  mmi       = rNGrams.MMI(rTraits.mMMIEta);
    size_t  vocab_size = rNGrams[0].Parent().pTargetTable()->Size();
    BSetQuestion* p_new_question = 
      new BSetQuestion(pred, vocab_size);

    size_t i_vocab;
    size_t i_best_change;
    

    // continue probing if any change was made in the previous iteration
    while (inserted || deleted) {
      inserted      = false;
      deleted       = false;

      // probe insertions
      for (i_vocab=0; i_vocab!=vocab_size; ++i_vocab) {
        if (!p_new_question->EvalRawToken(i_vocab)) {
          p_new_question->Set(i_vocab);
          double this_mmi = rNGrams.SplitMMI(*p_new_question, rTraits.mMMIAlpha, 
              rTraits.mMMIEta, &mass0, &mass1);

          if (this_mmi > mmi && mass0 >= rTraits.mMinInData && 
              mass1 >= rTraits.mMinInData) 
          {
            mmi           = this_mmi;
            i_best_change = i_vocab;
            inserted      = true;
          }

          p_new_question->Unset(i_vocab);
        }
      }

      // commit insertion
      if (inserted) {
        p_new_question->Set(i_best_change);
      }

      // probe deletions
      for (i_vocab=0; i_vocab!=vocab_size; ++i_vocab) {
        // only inspect positive questions
        if (p_new_question->EvalRawToken(i_vocab)) {
          p_new_question->Unset(i_vocab);
          double this_mmi = rNGrams.SplitMMI(*p_new_question, rTraits.mMMIAlpha, 
              rTraits.mMMIEta, &mass0, &mass1);

          if (this_mmi > mmi && mass0 >= rTraits.mMinInData && 
              mass1 >= rTraits.mMinInData) 
          {
            mmi           = this_mmi;
            i_best_change = i_vocab;
            deleted       = true;
          }

          p_new_question->Set(i_vocab);
        }
      }

      // commit deletion
      if (deleted) {
        p_new_question->Unset(i_best_change);
      }
    }

    // update entropy if possible
    if (NULL != pSplitMMI) {
      *pSplitMMI = mmi;
    }

    return p_new_question;
  }


  //***************************************************************************/
  //***************************************************************************/
  FLOAT
  BDTree::
  ScoreNGram(const NGram& rNGram)
  {
    BDTree* p_node = this;

    while (!p_node->IsLeaf()) {
      p_node = p_node->mpQuestion->Eval(rNGram) ? p_node->mpTree1 : p_node->mpTree0;
    } 

    if (NULL != p_node->mpBackoffDist) {
      return (*(p_node->mpBackoffDist))[rNGram[0]];
    }
    else {
      return (*(p_node->mpDist))[rNGram[0]];
    }
  } // ScoreNGram(const NGram& rNGram)


  //***************************************************************************/
  //***************************************************************************/
  FLOAT
  BDTree::
  ScoreNGramSubset(const NGramSubset& rNGrams)
  {
    NGramSubset::NGramContainer::const_iterator i;
    double  score = 0.0;

    for (i = rNGrams.mData.begin(); i != rNGrams.mData.end(); ++i) {
      double n_gram_score = ScoreNGram(**i);

      // we don't score the n-grams, whose prob is 0
      if (n_gram_score > 0) {
        score += (*i)->Counts() * my_log(n_gram_score);
      }
    }

    return score;
  } // ScoreNGramSubset(const NGramSubset& rNGrams, double r)


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  OutputNGramSubsetARPA(const NGramSubset& rNGrams, std::ostream& lm_stream, int rOrder)
  {
    const double log_e_10 = 2.30258;
    NGramSubset::NGramContainer::const_iterator i;
    const VocabularyTable *predictor_voc_table, *target_voc_table;
    target_voc_table = rNGrams.Parent().pTargetTable();
    predictor_voc_table = rNGrams.Parent().pPredictorTable();

    double  log_score;
    int j;
    NGram::TokenType voc_index;
    std::string word_string;

    for (i = rNGrams.mData.begin(); i != rNGrams.mData.end(); ++i) {
      double n_gram_score = ScoreNGram(**i);

      if(n_gram_score == 0)
	log_score = -99;
      else
      {
	log_score = my_log(n_gram_score);
	log_score /= log_e_10;
      }

      lm_stream << log_score << "" "";
      for(j = 1; j <= rOrder; j++)
      {
	voc_index = (**i)[rOrder - j];
	if((rOrder - j) == 0)
	  word_string = target_voc_table->IToA(voc_index);
	else
	  word_string = predictor_voc_table->IToA(voc_index);

	lm_stream << word_string << "" "";
      }

      lm_stream << std::endl;
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  Dump(std::ostream& rStream, const std::string& rPrefix) const
  {
    if (IsLeaf()) {
      if (NULL != mpBackoffDist) {
        mpBackoffDist->Dump(rStream, rPrefix);
      }
      else {
        mpDist->Dump(rStream, rPrefix);
      }

    }
    else {
      std::string new_pref;
      mpQuestion->Dump(rStream, rPrefix);

      new_pref = rPrefix + ""-  "";
      mpTree0->Dump(rStream, new_pref);

      new_pref = rPrefix + ""+  "";
      mpTree1->Dump(rStream, new_pref);
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  DumpImplicit() const
  {
    Dump(std::cout, "" "");
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  RecomputeDists()
  {
    if (!IsLeaf()) {
      mpTree0->RecomputeDists();
      mpTree1->RecomputeDists();
      if (NULL == mpDist) {
        //mpDist = new VecDistribution(mpTree0->mpDist->Size());
        mpDist = mpTree0->mpDist->Clone();
      }
      mpDist->Reset();
      mpDist->Merge(*(mpTree0->mpDist));
      mpDist->Merge(*(mpTree1->mpDist));
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  ComputeBackoffDists(BDTree* pParent, FLOAT r)
  {
    mpBackoffDist = mpDist->Clone();

    if (NULL != pParent && r > 0) {
      mpBackoffDist->Smooth(*(pParent->mpBackoffDist), r);
    }

    if (!IsLeaf()) {
      mpTree0->ComputeBackoffDists(this, r);
      mpTree1->ComputeBackoffDists(this, r);
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  CollectCounts(const NGramSubset& rNGrams)
  {
    NGramSubset::NGramContainer::const_iterator it;

    // go through all data
    for (it = rNGrams.mData.begin(); it != rNGrams.mData.end(); ++it) {
      BDTree* p_node  = this;
      NGram&  r_ngram = **it;
      
      while (!p_node->IsLeaf()) {
        p_node = p_node->mpQuestion->Eval(r_ngram) ? p_node->mpTree1 : p_node->mpTree0;
      } 

      VecDistribution* p_aux_distr = 
        dynamic_cast<VecDistribution*>(p_node->mpDist);

      if (NULL == p_aux_distr) {
        throw std::runtime_error(""Cannot collect couns for non-vector distribution implementations"");
      }

      p_aux_distr->mVec[r_ngram[0]]  += r_ngram.Counts();
      p_aux_distr->mN                += r_ngram.Counts();
    }
  }
  
  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  AdaptLeafDists(const NGramSubset& rNGrams, BDTreeBuildTraits& rTraits)
  {
    double r = rTraits.mAdaptR;

    NGramSubset::NGramContainer::const_iterator it;

    std::vector<BDTree*> leaf_map;
    std::vector<BDTree*>::iterator i_leaf;

    // fill the leaves collection
    GetLeaves(leaf_map);

    // go through all data
    for (it = rNGrams.mData.begin(); it != rNGrams.mData.end(); ++it) {
      BDTree* p_node  = this;
      NGram&  r_ngram = **it;
      
      while (!p_node->IsLeaf()) {
        p_node = p_node->mpQuestion->Eval(r_ngram) ? p_node->mpTree1 : p_node->mpTree0;
      } 

      // if mpBackoff is not initialized yet
      if (NULL == p_node->mpBackoffDist) {
        p_node->mpBackoffDist = p_node->mpDist->Clone();
        p_node->mpDist->mN      = 0.0;
        p_node->mpDist->Reset();
      }

      (*(p_node->mpDist))[r_ngram[0]]  += r_ngram.Counts();
      p_node->mpDist->mN                += r_ngram.Counts();
    }

    if (rTraits.mMapAdapt) {
      // recompute all distributions
      for (i_leaf = leaf_map.begin(); i_leaf != leaf_map.end(); ++i_leaf) {
        (*i_leaf)->mpDist->Fix();
        if (r > 0) {
          (*i_leaf)->mpDist->MapAdapt(*((**i_leaf).mpBackoffDist), r);
        }
      }
    }
    else {
      // recompute all distributions
      for (i_leaf = leaf_map.begin(); i_leaf != leaf_map.end(); ++i_leaf) {
        (*i_leaf)->mpDist->Fix();
        if (r > 0) {
          (*i_leaf)->mpDist->Smooth(*((**i_leaf).mpBackoffDist), r);
        }
      }
    }
  }
  

  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  ResetLeaves()
  {
    if (!IsLeaf()) {
      mpTree0->ResetLeaves();
      mpTree1->ResetLeaves();
    }
    else {
      mpDist->Reset();
    }
  }


  //***************************************************************************/
  //***************************************************************************/
  int
  BDTree::
  GetLeaves(std::vector<BDTree*>& rCollection)
  {
    int n = 0;
    if (IsLeaf()) {
      rCollection.insert(rCollection.end(), this);
      return 1;
    }
    else {
      n += mpTree0->GetLeaves(rCollection);
      n += mpTree1->GetLeaves(rCollection);
      return n;
    }
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  FillLeafSupervector(BasicVector<FLOAT>& rVector, bool backoff,
      bool includeCounts)
  {
    size_t vec_size;
    size_t vocab_size;
    size_t n_leaves;
    size_t i = 0;

    std::vector<BDTree*> leaves;
    std::vector<BDTree*>::iterator i_leaf;
    VecDistribution::Container::iterator i_prob;

    // compute sizes
    n_leaves    = GetLeaves(leaves);

    VecDistribution* p_aux_distr = 
      dynamic_cast<VecDistribution*>(leaves.front()->mpDist);

    if (NULL == p_aux_distr) {
      throw std::runtime_error(""Cannot collect counts for non-vector distribution implementations"");
    }

    vocab_size  = p_aux_distr->mVec.size();
    vec_size    = includeCounts ? n_leaves * vocab_size + n_leaves 
                                : n_leaves * vocab_size;

    // prepare new vector
    rVector.Destroy();
    rVector.Init(vec_size);
    rVector.Clear();

    // stack the leaves together and copy to the new supervector
    for (i_leaf = leaves.begin(); i_leaf != leaves.end(); ++i_leaf) {
      if (backoff) {
        p_aux_distr = dynamic_cast<VecDistribution*>((**i_leaf).mpBackoffDist);
      }
      else {
        p_aux_distr = dynamic_cast<VecDistribution*>((**i_leaf).mpDist);
      }


      if (NULL == p_aux_distr) {
        throw std::runtime_error(""Cannot collect couns for non-vector distribution implementations"");
      }

      VecDistribution::Container::iterator i_prob_begin = p_aux_distr->mVec.begin();
      VecDistribution::Container::iterator i_prob_end   = p_aux_distr->mVec.end();

      for (i_prob  = i_prob_begin; i_prob != i_prob_end; ++i_prob)
      {
        rVector[i] =  *i_prob;
        ++i;
      }

      if (includeCounts) {
        rVector[i] = backoff ? (**i_leaf).mpDist->Counts() 
                             : (**i_leaf).mpBackoffDist->Counts() ;
        i++;
      }
    }
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  BDTree::
  PushLeafSupervector(const std::vector<FLOAT>& rVector, bool backoff,
      bool includeCounts)
  {
    size_t vec_size;
    size_t vocab_size;
    size_t n_leaves;
    size_t i = 0;

    std::vector<BDTree*> leaves;
    std::vector<BDTree*>::iterator i_leaf;
    VecDistribution::Container::iterator i_prob;

    // compute sizes
    n_leaves    = GetLeaves(leaves);

    VecDistribution* p_aux_distr = 
      dynamic_cast<VecDistribution*>(leaves.front()->mpDist);

    if (NULL == p_aux_distr) {
      throw std::runtime_error(""Cannot collect couns for non-vector distribution implementations"");
    }

    vocab_size  = p_aux_distr->mVec.size();
    vec_size    = includeCounts ? n_leaves * vocab_size + n_leaves 
                                : n_leaves * vocab_size;

    // stack the leaves together and copy to the new supervector
    for (i_leaf = leaves.begin(); i_leaf != leaves.end(); ++i_leaf) {
      if (backoff) {
        p_aux_distr = dynamic_cast<VecDistribution*>((**i_leaf).mpBackoffDist);
      }
      else {
        p_aux_distr = dynamic_cast<VecDistribution*>((**i_leaf).mpDist);
      }

      VecDistribution::Container::iterator i_prob_begin = p_aux_distr->mVec.begin();
      VecDistribution::Container::iterator i_prob_end   = p_aux_distr->mVec.end();

      for (i_prob  = i_prob_begin; i_prob != i_prob_end; ++i_prob)
      {
        *i_prob = rVector[i];
        ++i;
      }

      if (includeCounts) {
        if (backoff) {
          (**i_leaf).mpBackoffDist->mN = rVector[i];
        }
        else {
          (**i_leaf).mpDist->mN = rVector[i];
        }

        i++;
      }
    }
  }



  //***************************************************************************/
  //***************************************************************************/
  // BSetQuestion
  //***************************************************************************/
  //***************************************************************************/
  BSetQuestion::
  BSetQuestion(std::istream& rStream, BDTreeHeader& rHeader)
  : BQuestion(), mSet(rHeader.mVocabSize), mPred(rHeader.mOrder)
  {
    Read(rStream, rHeader);
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  BSetQuestion::
  Set(const NGram::TokenType& rToken)
  {
    mSet[rToken] = 1;
  }


  //***************************************************************************/
  //***************************************************************************/
  void
  BSetQuestion::
  Unset(const NGram::TokenType& rToken)
  {
    //BSetQuestion::SetType::const_iterator i_ngram;

    //i_ngram = mSet.find(rToken);
    //if (i_ngram != mSet.end()) {
    //  mSet.erase(i_ngram); 
    //}

    mSet[rToken] = 0;
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  BSetQuestion::
  RandomShuffle(const NGram::TokenType& rToken)
  {
    int rand_value;

    rand_value = rand();
    if(rand_value < RAND_MAX/2)
      mSet[rToken] = 0;
    else
      mSet[rToken] = 1;
  }
  //***************************************************************************/
  //***************************************************************************/
  bool
  BSetQuestion::
  Eval(const BQuestionTerm& rTerm) const
  {
    const NGram* p_ngram = reinterpret_cast<const NGram*>(&rTerm);
    //BSetQuestion::SetType::const_iterator i_ngram;

    //i_ngram = mSet.find((*p_ngram)[mPred]);
    //return !(i_ngram == mSet.end() || *i_ngram == 0);
    return mSet[(*p_ngram)[mPred]];
  }

  //***************************************************************************/
  //***************************************************************************/
  bool
  BSetQuestion::
  EvalRawToken(const NGram::TokenType& rToken) const
  {
    //const NGram* p_ngram = static_cast<const NGram*>(&rTerm);
    //BSetQuestion::SetType::const_iterator i_ngram;

    //i_ngram = mSet.find(rToken);
    //return !(i_ngram == mSet.end() || *i_ngram == 0);
    return mSet[rToken];
  }

  //***************************************************************************/
  //***************************************************************************/
  BSetQuestion*
  BSetQuestion::
  Clone()
  {
    return new BSetQuestion(*this);
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  BSetQuestion::
  Dump(std::ostream& rStream, const std::string& rPrefix) const
  {
    rStream << rPrefix << ""================================"" << std::endl;
    rStream << rPrefix << ""= Simple question "" << std::endl;
    rStream << rPrefix << ""=  Predictor: "" << mPred << std::endl;
    rStream << rPrefix << ""=  Positive: "";

    BSetQuestion::SetType::const_iterator i;
    for (i = mSet.begin(); i!=mSet.end(); ++i) {
      rStream << *i<< ""  "";
    }
    rStream << std::endl;
    rStream << rPrefix << ""================================"" << std::endl;
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  BSetQuestion::
  DumpImplicit() const
  { Dump(std::cout, ""Implicit dump ""); }



  //***************************************************************************/
  //***************************************************************************/
  SparseBigramMatrix::~SparseBigramMatrix()
  {
    int i;
    for(i = 0; i < mPredictorVocabSize; i++)
      delete [] mPointerVector[i];
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  SparseBigramMatrix::CreateSizeVector(const NGramSubset& rNGrams, const BSetQuestion& rQuestion, int pred, bool YesAnswer)
  {
    int vocab_size = rNGrams.Parent().pPredictorTable()->Size();
    bool already_seen;
    BasicVector< NGram::TokenType> seen_contexts(vocab_size);
    NGram::TokenType prev_present_token = -1;

    // iterate over all N-grams at this particular node
    NGramSubset::NGramContainer::const_iterator it;
    for (it=rNGrams.mData.begin(); it!=rNGrams.mData.end(); ++it) 
    {
      already_seen = false;
      NGram::TokenType* predictor_token = &((**it)[pred]);
      NGram::TokenType* present_token = &((**it)[0]);
      NGram::ProbType   counts = (*it)->Counts();

      if (!(counts > 0)) {
        continue;
      }
      // assert(counts > 0); 

      // The N-grams are all sorted accordind to most current words (first 
      // present words, then -1 context etc.). We take benefit of this since 
      // we must count not different N-grams but N-1 grams with different 
      // predictors

      // we start reading N-grams with different present word
      if(*present_token != prev_present_token) {
	prev_present_token = *present_token;
	seen_contexts.Clear();
      }
      else if(seen_contexts[*predictor_token]) {
	already_seen = true;
      }


      if(!already_seen)
      {
	if((YesAnswer && rQuestion.Eval(**it))
	  || (!YesAnswer && !rQuestion.Eval(**it)))
	{ 
	  mSizeVector[*predictor_token]++;

	  seen_contexts[*predictor_token] = 1;
	}
      }
    }
  }

  //***************************************************************************/
  //***************************************************************************/
  void
  SparseBigramMatrix::AllocateMem()
  {
    int i, size;
    for(i = 0; i < mPredictorVocabSize; i++)  
    {
      size = mSizeVector[i];
      //this->mPointerVector[i] = 0;
      if(size)
	mPointerVector[i] = new SparseBigramCell[size];
      else 
	mPointerVector[i] = NULL;
    }

  }

  //***************************************************************************/
  //***************************************************************************/ 
  void
  SparseBigramMatrix::Fill(const NGramSubset& rNGrams, 
      const BSetQuestion& rQuestion, const int pred, const bool YesAnswer)
  {
    // iterate over all N-grams at this particular node
    NGramSubset::NGramContainer::const_iterator it;
    int i;
    bool bigram_found;

    for (it=rNGrams.mData.begin(); it!=rNGrams.mData.end(); ++it) 
    {
      NGram::TokenType* present_token = &((**it)[0]);
      NGram::TokenType* predictor_token = &((**it)[pred]);
      NGram::ProbType   counts = (*it)->Counts();

      if (!(counts > 0)) {
        continue;
      }
      //assert(counts > 0); 

      if((YesAnswer && rQuestion.Eval(**it))
	  || (!YesAnswer && !rQuestion.Eval(**it)))
      {
	bigram_found = false;
	for(i = 0; i < mSizeVector[*predictor_token]; i++)
	{
	  // do we start from zero or 1????
	  int     current_column = (this->mPointerVector[*predictor_token] + i)->GetColumn();
	  double  current_count  = (this->mPointerVector[*predictor_token] + i)->GetCount();

          // Ondra asks: WHY break ????
	  if (!(current_count > 0)) {
	    break;
          }

	  else if(*present_token == current_column)
	  {
	    (this->mPointerVector[*predictor_token] + i)->IncrementCount(counts);
	    mMarginalCountsPresent[*present_token] += counts;
	    mMarginalCountsPredictor[*predictor_token] += counts;
	    mTotalSum += counts;
	    bigram_found = true;

	    break;
	  }
	}

	if(!bigram_found)
	{
	  assert(i < mSizeVector[*predictor_token]);

	  (this->mPointerVector[*predictor_token] + i)->SetCell(*present_token, counts);
	  mMarginalCountsPresent[*present_token] += counts;
	  mMarginalCountsPredictor[*predictor_token] += counts;
	  mTotalSum += counts;
	}
      }
    }
  }

  //***************************************************************************/
  //***************************************************************************/  
  SparseBigramMatrix::ProbType
  SparseBigramMatrix::InsertBasicElement(SparseBigramMatrix& MoveFromThisSet, 
      const int Predictor)
  {
    int i, helper;
    double log_likelihood_sum = 0;
    double counts_moved = 0;
    SparseBigramCell *AuxCopy;


    // Iterate over all elements in the basic element (i.e. over all present 
    // words) to be inserted
    for(i = 0; i < MoveFromThisSet.mSizeVector[Predictor]; i++)
    {
      // do we start from zero or 1????
      int     current_column = (MoveFromThisSet.mPointerVector[Predictor] + i)->GetColumn();
      double  current_count  = (MoveFromThisSet.mPointerVector[Predictor] + i)->GetCount();

      // assert(current_count > 0);

      MoveFromThisSet.mMarginalCountsPresent[current_column] -= current_count;
      this->mMarginalCountsPresent[current_column] += current_count;
      counts_moved += current_count;
    }

    this->mTotalSum += counts_moved;
    MoveFromThisSet.mTotalSum -= counts_moved;
    // Actually we do not use predctor marginal count vector
    MoveFromThisSet.mMarginalCountsPredictor[Predictor] -= counts_moved;

    // assert(MoveFromThisSet.mMarginalCountsPredictor[Predictor] == 0);

    this->mMarginalCountsPredictor[Predictor] += counts_moved;

    // assert(this->mMarginalCountsPredictor[Predictor] == counts_moved);

    // update size vectors
    helper = this->mSizeVector[Predictor];
    this->mSizeVector[Predictor] =  MoveFromThisSet.mSizeVector[Predictor];
    MoveFromThisSet.mSizeVector[Predictor] = helper;
    // We updated marginal count matrices and TotalSum, now move whole basic elements
    AuxCopy = this->mPointerVector[Predictor];
    this->mPointerVector[Predictor] = MoveFromThisSet.mPointerVector[Predictor];
    MoveFromThisSet.mPointerVector[Predictor] = AuxCopy;
      
    log_likelihood_sum = this->CountLogLikelihood(MoveFromThisSet);

    return log_likelihood_sum;
  }

  //***************************************************************************/
  //***************************************************************************/  
  SparseBigramMatrix::ProbType
  SparseBigramMatrix::CountLogLikelihood(const SparseBigramMatrix& SecondSet) const
  {
    int i;
    double log_likelihood = 0, count_A, count_A_, total_A, total_A_;

    // Formula sum_w[C(w,A)logC(w,A) + C(w,A_complement)logC(w,A_complement)] - C(A)logC(A) - C(A_complement)logC(A_complement)      
    // Iterate over all elements in the basic element (i.e. over all present words) to be inserted
    for(i = 0; i < mPresentVocabSize; i++)
    {
      count_A  = this->mMarginalCountsPresent[i];
      count_A_ = SecondSet.mMarginalCountsPresent[i];

      if(count_A > 0)
        log_likelihood += count_A  * my_log(count_A);
      if(count_A_ > 0)
	log_likelihood += count_A_ * my_log(count_A_);
    }
    total_A  = this->mTotalSum;
    total_A_ = SecondSet.mTotalSum;

    // if (close_enough(total_A, 0.0, 10)) {
    //   total_A = 0.0;
    // }
    // if (close_enough(total_A_, 0.0, 10)) {
    //   total_A_ = 0.0;
    // }

    assert(total_A >= 0 && total_A_ >= 0);

    if(total_A > 0) {
      log_likelihood -= total_A  * my_log(total_A);
    }
    if(total_A_ > 0) {
      log_likelihood -= total_A_ * my_log(total_A_);
    }

    return log_likelihood;
  }

  //***************************************************************************/
  //***************************************************************************/  
  MorphVocabSection:: MorphVocabSection(NGramSubsets& rNGrams, int pred)
  {
    int i, vocab_total;
    std::string factor_type, wrd;
    NGram::TokenType ngram_token;
    NGramSubset::NGramContainer::const_iterator it;

    it = rNGrams[0].mData.begin();
    ngram_token = (**it)[pred];

    vocab_total = rNGrams[0].Parent().pPredictorTable()->Size();
    factor_type = rNGrams[0].Parent().pPredictorTable()->IToA(ngram_token);

    mFirst = 0;

    for(i =0 ; i < vocab_total; i++)
    {
      wrd = rNGrams[0].Parent().pPredictorTable()->IToA(i);
      if(factor_type[0] == wrd[0])
      {
	if(mFirst == 0)
	  mFirst = i;

	mLast  = i;
      }
      else
      {
	if(mFirst != 0)
	  break;
	else
	  continue;
      }
    }
  }


} // namespace STK

// EOF
",16238,True,2689.473121927978,median
"//%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the ""Software""),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>
#include <iostream>
#include <Pegasus/Common/Constants.h>
#include <Pegasus/Common/XmlParser.h>
#include <Pegasus/Common/XmlReader.h>
#include <Pegasus/Common/System.h>
#include <Pegasus/Common/XmlWriter.h>
#include <Pegasus/Common/HTTPMessage.h>
#include <Pegasus/Common/CIMMessage.h>
#include <Pegasus/Common/Exception.h>
#include <Pegasus/Common/BinaryCodec.h>
#include ""CIMOperationResponseDecoder.h""
#include ""CIMClientRep.h""

#include <Pegasus/Common/MessageLoader.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

CIMOperationResponseDecoder::CIMOperationResponseDecoder(
    MessageQueue* outputQueue,
    MessageQueue* encoderQueue,
    ClientAuthenticator* authenticator)
    :
    MessageQueue(PEGASUS_QUEUENAME_OPRESPDECODER),
    _outputQueue(outputQueue),
    _encoderQueue(encoderQueue),
    _authenticator(authenticator)
{
}

CIMOperationResponseDecoder::~CIMOperationResponseDecoder()
{
}

void  CIMOperationResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue)
{
    _encoderQueue = encoderQueue;
}

void CIMOperationResponseDecoder::handleEnqueue()
{
    Message* message = dequeue();

    if (!message)
        return;

    switch (message->getType())
    {
        case HTTP_MESSAGE:
        {
            HTTPMessage* httpMessage = (HTTPMessage*)message;
            _handleHTTPMessage(httpMessage);
            break;
        }

        default:
            PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
            break;
    }

    delete message;
}

void CIMOperationResponseDecoder::setDataStorePointer(
    ClientPerfDataStore* perfDataStore_ptr)
{   dataStore = perfDataStore_ptr;
}

void CIMOperationResponseDecoder::_handleHTTPMessage(HTTPMessage* httpMessage)
{
    //
    // Parse the HTTP message:
    //
    TimeValue networkEndTime = TimeValue::getCurrentTime();

    String  startLine;
    Array<HTTPHeader> headers;
    const char* content;
    Uint32  contentLength;
    Boolean cimReconnect=false;

    if (httpMessage->message.size() == 0)
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.EMPTY_RESPONSE"",
            ""Connection closed by CIM Server."");
        String mlString(MessageLoader::getMessage(mlParms));

        CIMClientMalformedHTTPException* malformedHTTPException =
            new CIMClientMalformedHTTPException(mlString);

        ClientExceptionMessage * response =
            new ClientExceptionMessage(malformedHTTPException);

       //reconnect and resend next request
        response->setCloseConnect(true);

        _outputQueue->enqueue(response);
        return;
    }


    httpMessage->parse(startLine, headers, contentLength);

    //
    // Check for Connection: Close
    //
    const char* connectClose;
    if (HTTPMessage::lookupHeader(headers, ""Connection"", connectClose, false))
    {
        if (System::strcasecmp(connectClose, ""Close"") == 0)
        {
            //reconnect and then resend next request.
            cimReconnect=true;
        }
    }
    //
    // Get the status line info
    //
    String httpVersion;
    Uint32 statusCode;
    String reasonPhrase;

    Boolean parsableMessage = HTTPMessage::parseStatusLine(
        startLine, httpVersion, statusCode, reasonPhrase);
    if (!parsableMessage)
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.MALFORMED_RESPONSE"",
            ""Malformed HTTP response message."");
        String mlString(MessageLoader::getMessage(mlParms));

        CIMClientMalformedHTTPException* malformedHTTPException =
            new CIMClientMalformedHTTPException(mlString);

        ClientExceptionMessage * response =
            new ClientExceptionMessage(malformedHTTPException);

        response->setCloseConnect(cimReconnect);

        _outputQueue->enqueue(response);
        return;
    }

    if (ClientTrace::displayOutput(ClientTrace::TRACE_CON))    {
        cout << ""CIMOperatonResponseDecoder"";
        httpMessage->printAll(cout);
    }
    if (ClientTrace::displayOutput(ClientTrace::TRACE_LOG))
    {
        Logger::put(Logger::STANDARD_LOG,
            ""CIMCLient"",
            Logger::INFORMATION,
            ""CIMOperationRequestDecoder::Response, XML content: $0"",
            httpMessage->message.getData());
    }

    try
    {
        if (_authenticator->checkResponseHeaderForChallenge(headers))
        {
            // If we had a cookie, it must have been a wrong one
            _authenticator->clearCookie();

            //
            // Get the original request, put that in the encoder's queue for
            // re-sending with authentication challenge response.
            //
            Message* reqMessage = _authenticator->releaseRequestMessage();

            if (cimReconnect == true)
            {
                reqMessage->setCloseConnect(cimReconnect);
                _outputQueue->enqueue(reqMessage);
            }
            else
            {
                _encoderQueue->enqueue(reqMessage);
            }

            return;
        }
        else
        {
            //
            // Received a valid/error response from the server.
            // We do not need the original request message anymore, hence
            // delete the request message by getting the handle from the
            // ClientAuthenticator.
            //
            Message* reqMessage = _authenticator->releaseRequestMessage();
            delete reqMessage;
        }
    }
    catch (InvalidAuthHeader& e)
    {
        CIMClientMalformedHTTPException* malformedHTTPException =
            new CIMClientMalformedHTTPException(e.getMessage());
        ClientExceptionMessage * response =
            new ClientExceptionMessage(malformedHTTPException);

        response->setCloseConnect(cimReconnect);
        _outputQueue->enqueue(response);
        return;
    }

    // Store incoming cookie, if present.
    _authenticator->parseCookie(headers);

    // We have the response.  If authentication failed, we will generate a
    // CIMClientHTTPErrorException below with the ""401 Unauthorized"" status
    // in the (re-challenge) response.

    //
    // Check for a success (200 OK) response
    //
    if (statusCode != HTTP_STATUSCODE_OK)
    {
        String cimError;
        String pegasusError;

        HTTPMessage::lookupHeader(headers, ""CIMError"", cimError, true);
        HTTPMessage::lookupHeader(
            headers, PEGASUS_HTTPHEADERTAG_ERRORDETAIL, pegasusError);
        try
        {
            pegasusError = XmlReader::decodeURICharacters(pegasusError);
        }
        catch (ParseError&)
        {
            // Ignore this exception.  We're more interested in having the
            // message in encoded form than knowing that the format is invalid.
        }

        CIMClientHTTPErrorException* httpError =
            new CIMClientHTTPErrorException(statusCode, reasonPhrase,
                                            cimError, pegasusError);
        ClientExceptionMessage * response =
            new ClientExceptionMessage(httpError);

        response->setCloseConnect(cimReconnect);
        _outputQueue->enqueue(response);
        return;
    }

    //
    // Search for ""CIMOperation"" header:
    //
    const char* cimOperation;

    if (!HTTPMessage::lookupHeader(
        headers, ""CIMOperation"", cimOperation, true))
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.MISSING_CIMOP_HEADER"",
            ""Missing CIMOperation HTTP header"");
        String mlString(MessageLoader::getMessage(mlParms));

        CIMClientMalformedHTTPException* malformedHTTPException =
            new CIMClientMalformedHTTPException(mlString);

        ClientExceptionMessage * response =
            new ClientExceptionMessage(malformedHTTPException);

        response->setCloseConnect(cimReconnect);

        _outputQueue->enqueue(response);
        return;
    }

    //
    // Search for ""Content-Type"" header:
    //

    // BUG 572, Use of Content-Type header and change error msg.
    // If header exists, test type.  If not, ignore. We will find
    // content type errors in text analysis.
    // content-type header  value format:
    //              type ""/"" subtype *( "";"" parameter )
    // ex. text/xml;Charset=""utf8""
    const char* cimContentType;
    bool binaryResponse = false;

    if (HTTPMessage::lookupHeader(
            headers, ""Content-Type"", cimContentType, true))
    {
        String type;
        String charset;

        if (!HTTPMessage::parseContentTypeHeader(
                cimContentType, type, charset) ||
            (((!String::equalNoCase(type, ""application/xml"") &&
              !String::equalNoCase(type, ""text/xml"")) ||
             !String::equalNoCase(charset, ""utf-8""))
            && !(binaryResponse=String::equalNoCase(
                type, ""application/x-openpegasus""))
        ))
        {
            CIMClientMalformedHTTPException* malformedHTTPException = new
                CIMClientMalformedHTTPException(
                    ""Bad Content-Type HTTP header; "" + String(cimContentType));
            ClientExceptionMessage * response =
                new ClientExceptionMessage(malformedHTTPException);

            response->setCloseConnect(cimReconnect);

            _outputQueue->enqueue(response);
            return;
        }
    }
    // comment out the error rejection code if the content-type header does
    //    not exist
#ifdef PEGASUS_REJECT_ON_MISSING_CONTENTTYPE_HEADER
    else
    {
        CIMClientMalformedHTTPException* malformedHTTPException = new
            CIMClientMalformedHTTPException
                (""Missing Content-Type HTTP header; "");
        ClientExceptionMessage * response =
            new ClientExceptionMessage(malformedHTTPException);

        response->setCloseConnect(cimReconnect);

        _outputQueue->enqueue(response);
        return;
    }
#endif

    // look for any cim status codes. The HTTPConnection level would have
    // added them here.

    const char* cimStatusCodeValue;
    Boolean found = HTTPMessage::lookupHeader(headers, ""CIMStatusCode"",
        cimStatusCodeValue, true);
    CIMStatusCode cimStatusCodeNumber = CIM_ERR_SUCCESS;

    if (found &&
        (cimStatusCodeNumber = (CIMStatusCode) atoi(cimStatusCodeValue)) !=
             CIM_ERR_SUCCESS)
    {
        String cimStatusCodeDescription;
        found = HTTPMessage::lookupHeader(headers, ""CIMStatusCodeDescription"",
            cimStatusCodeDescription, true);
        if (found && cimStatusCodeDescription.size() > 0)
        {
            try
            {
                cimStatusCodeDescription =
                    XmlReader::decodeURICharacters(cimStatusCodeDescription);
            }
            catch (ParseError&)
            {
            }
        } // if there is a description with the code

        CIMException* cimStatusException =
            new CIMException(cimStatusCodeNumber,cimStatusCodeDescription);
        cimStatusException->setContentLanguages(httpMessage->contentLanguages);
        ClientExceptionMessage * response =
            new ClientExceptionMessage(cimStatusException);

        response->setCloseConnect(cimReconnect);

        _outputQueue->enqueue(response);
        return;
    }

    const char* serverTime;
    if (HTTPMessage::lookupHeader(
            headers, ""WBEMServerResponseTime"", serverTime, true))
    {
        Uint32 sTime = (Uint32) atol(serverTime);
        dataStore->setServerTime(sTime);
    }


    // Calculate the beginning of the content from the message size and
    // the content length.
    if (binaryResponse)
    {
        // binary the ""Content"" also contains a few padding '\\0' to align
        // data structures to 8byte boundary
        // the padding '\\0' are also part of the counted contentLength
        Uint32 headerEnd = httpMessage->message.size() - contentLength;
        Uint32 binContentStart = CIMBuffer::round(headerEnd);

        contentLength = contentLength - (binContentStart - headerEnd);
        content = httpMessage->message.getData() + binContentStart;
    }
    else
    {
        content = httpMessage->message.getData() +
            httpMessage->message.size() - contentLength;
    }

    //
    // If it is a method response, then dispatch it to be handled:
    //

    if (System::strcasecmp(cimOperation, ""MethodResponse"") != 0)
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.EXPECTED_METHODRESPONSE"",
            ""Received CIMOperation HTTP header value \\""$1\\"", expected ""
                ""\\""MethodResponse\\"""",
            cimOperation);
        String mlString(MessageLoader::getMessage(mlParms));

        CIMClientMalformedHTTPException* malformedHTTPException =
            new CIMClientMalformedHTTPException(mlString);

        ClientExceptionMessage * response =
            new ClientExceptionMessage(malformedHTTPException);

        response->setCloseConnect(cimReconnect);

        _outputQueue->enqueue(response);
        return;
    }

    dataStore->setResponseSize(contentLength);
    dataStore->setEndNetworkTime(networkEndTime);
    _handleMethodResponse(content, contentLength,
        httpMessage->contentLanguages, cimReconnect, binaryResponse);
}

void CIMOperationResponseDecoder::_handleMethodResponse(
    const char* content,
    Uint32 contentLength,
    const ContentLanguageList& contentLanguages,
    Boolean cimReconnect,
    Boolean binaryResponse)
{
    Message* response = 0;

    //
    // Decode binary messages up-front and skip remainder:
    //

    if (binaryResponse)
    {
        // Note: this may throw an exception which will be caught by caller.

        CIMBuffer in((char*)content, contentLength);
        CIMBufferReleaser buf_(in);

        CIMResponseMessage* msg = BinaryCodec::decodeResponse(in);

        msg->operationContext.set(
            ContentLanguageListContainer(contentLanguages));
        msg->setCloseConnect(cimReconnect);
        _outputQueue->enqueue(msg);

        return;
    }

    //
    // Create and initialize XML parser:
    //

    XmlParser parser((char*)content);
    XmlEntry entry;

    try
    {
        //
        // Process <?xml ... >
        //

        const char* xmlVersion = 0;
        const char* xmlEncoding = 0;

        XmlReader::getXmlDeclaration(parser, xmlVersion, xmlEncoding);

        //
        // Process <CIM ... >
        //

        const char* cimVersion = 0;
        const char* dtdVersion = 0;

        // ATTN-RK-P3-20020416: Need to validate these versions?
        XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);

        //
        // Expect <MESSAGE ... >
        //

        String messageId;
        String protocolVersion;

        if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
        {
            MessageLoaderParms mlParms(
                ""Client.CIMOperationResponseDecoder.EXPECTED_MESSAGE_ELEMENT"",
                ""expected MESSAGE element"");
            throw XmlValidationError(parser.getLine(), mlParms);
        }

        // test for valid protocolVersion
        if (!XmlReader::isSupportedProtocolVersion(protocolVersion))
        {
            MessageLoaderParms mlParms(
                ""Client.CIMOperationResponseDecoder.UNSUPPORTED_PROTOCOL"",
                ""Received unsupported protocol version \\""$0\\"", expected ""
                    ""\\""$1\\"""",
                protocolVersion,
                ""1.[0-9]+"");
            String mlString(MessageLoader::getMessage(mlParms));

            CIMClientResponseException* responseException =
                new CIMClientResponseException(mlString);

            ClientExceptionMessage * clientExceptionMessage =
                new ClientExceptionMessage(responseException);

            clientExceptionMessage->setCloseConnect(cimReconnect);

            _outputQueue->enqueue(clientExceptionMessage);
            return;
        }

        //
        // Expect <SIMPLERSP ... >
        //

        XmlReader::expectStartTag(parser, entry, ""SIMPLERSP"");

        //
        // Expect <IMETHODRESPONSE ... >
        //

        const char* iMethodResponseName = 0;
        Boolean isEmptyTag = false;

        if (XmlReader::getIMethodResponseStartTag(
                parser, iMethodResponseName, isEmptyTag))
        {
            //
            // Dispatch the method:
            //

            if (System::strcasecmp(iMethodResponseName, ""GetClass"") == 0)
                response = _decodeGetClassResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""GetInstance"") == 0)
                response = _decodeGetInstanceResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""EnumerateClassNames"") == 0)
                response = _decodeEnumerateClassNamesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""References"") == 0)
                response = _decodeReferencesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""ReferenceNames"") == 0)
                response = _decodeReferenceNamesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""AssociatorNames"") == 0)
                response = _decodeAssociatorNamesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""Associators"") == 0)
                response = _decodeAssociatorsResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""CreateInstance"") == 0)
                response = _decodeCreateInstanceResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName,""EnumerateInstanceNames"") == 0)
                response = _decodeEnumerateInstanceNamesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName,""EnumerateInstances"") == 0)
                response = _decodeEnumerateInstancesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""GetProperty"") == 0)
                response = _decodeGetPropertyResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""SetProperty"") == 0)
                response = _decodeSetPropertyResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""DeleteQualifier"") == 0)
                response = _decodeDeleteQualifierResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""GetQualifier"") == 0)
                response = _decodeGetQualifierResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""SetQualifier"") == 0)
                response = _decodeSetQualifierResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""EnumerateQualifiers"") == 0)
                response = _decodeEnumerateQualifiersResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""EnumerateClasses"") == 0)
                response = _decodeEnumerateClassesResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""CreateClass"") == 0)
                response = _decodeCreateClassResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""ModifyClass"") == 0)
                response = _decodeModifyClassResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""ModifyInstance"") == 0)
                response = _decodeModifyInstanceResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""DeleteClass"") == 0)
                response = _decodeDeleteClassResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(
                         iMethodResponseName, ""DeleteInstance"") == 0)
                response = _decodeDeleteInstanceResponse(
                    parser, messageId, isEmptyTag);
            else if (System::strcasecmp(iMethodResponseName, ""ExecQuery"") == 0)
                response = _decodeExecQueryResponse(
                    parser, messageId, isEmptyTag);
// EXP_PULL_BEGIN
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenEnumerateInstances"") == 0)
            {
                response = _decodeOpenEnumerateInstancesResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenEnumerateInstancePaths"") == 0)
            {
                response = _decodeOpenEnumerateInstancePathsResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenReferenceInstances"") == 0)
            {
                response = _decodeOpenReferenceInstancesResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenReferenceInstancePaths"") == 0)
            {
                response = _decodeOpenReferenceInstancePathsResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenAssociatorInstances"") == 0)
            {
                response = _decodeOpenAssociatorInstancesResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenAssociatorInstancePaths"") == 0)
            {
                response = _decodeOpenAssociatorInstancePathsResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""OpenQueryInstances"") == 0)
            {
                response = _decodeOpenQueryInstancesResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""PullInstancesWithPath"") == 0)
            {
                response = _decodePullInstancesWithPathResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""PullInstancePaths"") == 0)
            {
                response = _decodePullInstancePathsResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""PullInstances"") == 0)
            {
                response = _decodePullInstancesResponse(
                    parser, messageId, isEmptyTag);
            }
            else if (System::strcasecmp(
                    iMethodResponseName, ""CloseEnumeration"") == 0)
            {
                response = _decodeCloseEnumerationResponse(
                    parser, messageId, isEmptyTag);
            }

            else if (System::strcasecmp(
                iMethodResponseName, ""EnumerationCount"") == 0)
            {
                response = _decodeEnumerationCountResponse(
                    parser, messageId, isEmptyTag);
            }
//EXP_PULL_END
            else
            {
                MessageLoaderParms mlParms(
                    ""Client.CIMOperationResponseDecoder.UNRECOGNIZED_NAME"",
                    ""Unrecognized IMethodResponse name \\""$0\\"""",
                    iMethodResponseName);
                throw XmlValidationError(parser.getLine(), mlParms);
            }

            //
            // Handle end tag:
            //

            if (!isEmptyTag)
            {
                XmlReader::expectEndTag(parser, ""IMETHODRESPONSE"");
            }
        }
        else if (XmlReader::getMethodResponseStartTag(
                     parser, iMethodResponseName, isEmptyTag))
        {
            response = _decodeInvokeMethodResponse(
                parser, messageId, iMethodResponseName, isEmptyTag);


            //
            // Handle end tag:
            //
            if (!isEmptyTag)
            {
                XmlReader::expectEndTag(parser, ""METHODRESPONSE"");
            }
        }
        else
        {
            MessageLoaderParms mlParms(
                ""Client.CIMOperationResponseDecoder.""
                    ""EXPECTED_METHODRESPONSE_OR_IMETHODRESPONSE_ELEMENT"",
                ""expected METHODRESPONSE or IMETHODRESPONSE element"");
            throw XmlValidationError(parser.getLine(), mlParms);
        }

        //
        // Handle end tags:
        //
        XmlReader::expectEndTag(parser, ""SIMPLERSP"");
        XmlReader::expectEndTag(parser, ""MESSAGE"");
        XmlReader::expectEndTag(parser, ""CIM"");
    }
    catch (XmlException& x)
    {
        if (response)
        {
            delete response;
        }

        response = new ClientExceptionMessage(
            new CIMClientXmlException(x.getMessage()));
    }
    catch (Exception& x)
    {
        // Might get MalformedObjectNameException, InvalidNameException, etc.

        if (response)
        {
            delete response;
        }

        response = new ClientExceptionMessage(
            new CIMClientResponseException(x.getMessage()));
    }

//l10n start
// l10n TODO - might want to move A-L and C-L to Message
// to make this more maintainable
    // Add the language header to the request
    CIMMessage * cimmsg = dynamic_cast<CIMMessage *>(response);
    if (cimmsg != NULL)
    {
        cimmsg->operationContext.set(
            ContentLanguageListContainer(contentLanguages));
    }
    else
    {
        ;    // l10n TODO - error back to client here
    }
// l10n end

    response->setCloseConnect(cimReconnect);


    _outputQueue->enqueue(response);
}

CIMCreateClassResponseMessage*
    CIMOperationResponseDecoder::_decodeCreateClassResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMCreateClassResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMCreateClassResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMGetClassResponseMessage*
    CIMOperationResponseDecoder::_decodeGetClassResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (isEmptyImethodresponseTag)
    {
        MessageLoaderParms mlParms(""Common.XmlReader.EXPECTED_OPEN"",
            ""Expected open of $0 element"", ""IMETHODRESPONSE"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
    else if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMGetClassResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            CIMClass());
    }
    else if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
    {
        CIMClass cimClass;

        if ((entry.type == XmlEntry::EMPTY_TAG) ||
            !XmlReader::getClassElement(parser, cimClass))
        {
            MessageLoaderParms mlParms(
                ""Client.CIMOperationResponseDecoder.EXPECTED_CLASS_ELEMENT"",
                ""expected CLASS element"");
            throw XmlValidationError(parser.getLine(), mlParms);
        }

        XmlReader::expectEndTag(parser, ""IRETURNVALUE"");

        return new CIMGetClassResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            cimClass);
    }
    else
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.""
                ""EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT"",
            ""expected ERROR or IRETURNVALUE element"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
}

CIMModifyClassResponseMessage*
    CIMOperationResponseDecoder::_decodeModifyClassResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMModifyClassResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMModifyClassResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMEnumerateClassNamesResponseMessage*
    CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMName> classNames;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMEnumerateClassNamesResponseMessage(
                messageId,
                cimException,
                QueueIdStack(),
                Array<CIMName>());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMName className;

                while (XmlReader::getClassNameElement(parser, className, false))
                    classNames.append(className);

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMEnumerateClassNamesResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        classNames);
}

CIMEnumerateClassesResponseMessage*
    CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMClass> cimClasses;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMEnumerateClassesResponseMessage(
                messageId,
                cimException,
                QueueIdStack(),
                Array<CIMClass>());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMClass cimClass;

                while (XmlReader::getClassElement(parser, cimClass))
                    cimClasses.append(cimClass);

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMEnumerateClassesResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        cimClasses);
}

CIMDeleteClassResponseMessage*
    CIMOperationResponseDecoder::_decodeDeleteClassResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMDeleteClassResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMDeleteClassResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMCreateInstanceResponseMessage*
    CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (isEmptyImethodresponseTag)
    {
        MessageLoaderParms mlParms(""Common.XmlReader.EXPECTED_OPEN"",
            ""Expected open of $0 element"", ""IMETHODRESPONSE"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
    else if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMCreateInstanceResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            CIMObjectPath());
    }
    else if (XmlReader::testStartTag(parser, entry, ""IRETURNVALUE""))
    {
        CIMObjectPath instanceName;
        XmlReader::getInstanceNameElement(parser, instanceName);

        XmlReader::expectEndTag(parser, ""IRETURNVALUE"");

        return new CIMCreateInstanceResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            instanceName);
    }
    else
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.""
                ""EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT"",
            ""expected ERROR or IRETURNVALUE element"");

        throw XmlValidationError(parser.getLine(), mlParms);
    }
}

CIMGetInstanceResponseMessage*
    CIMOperationResponseDecoder::_decodeGetInstanceResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (isEmptyImethodresponseTag)
    {
        MessageLoaderParms mlParms(""Common.XmlReader.EXPECTED_OPEN"",
            ""Expected open of $0 element"", ""IMETHODRESPONSE"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
    else if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMGetInstanceResponseMessage(
            messageId,
            cimException,
            QueueIdStack());
    }
    else if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
    {
        CIMInstance cimInstance;

        if ((entry.type == XmlEntry::EMPTY_TAG) ||
            !XmlReader::getInstanceElement(parser, cimInstance))
        {
            MessageLoaderParms mlParms(
                ""Client.CIMOperationResponseDecoder.EXPECTED_INSTANCE_ELEMENT"",
                ""expected INSTANCE element"");
            throw XmlValidationError(parser.getLine(), mlParms);
        }

        XmlReader::expectEndTag(parser, ""IRETURNVALUE"");

        CIMGetInstanceResponseMessage* msg = new CIMGetInstanceResponseMessage(
            messageId,
            cimException,
            QueueIdStack());
        msg->getResponseData().setInstance(cimInstance);
        return msg;
    }
    else
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.""
                ""EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT"",
            ""expected ERROR or IRETURNVALUE element"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
}

CIMModifyInstanceResponseMessage*
    CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMModifyInstanceResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMModifyInstanceResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMEnumerateInstanceNamesResponseMessage*
    CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> instanceNames;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMEnumerateInstanceNamesResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                String className;
                Array<CIMKeyBinding> keyBindings;

                while (XmlReader::getInstanceNameElement(
                    parser, className, keyBindings))
                {
                    CIMObjectPath r(
                        String::EMPTY,
                        CIMNamespaceName(),
                        className,
                        keyBindings);
                    instanceNames.append(r);
                }

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMEnumerateInstanceNamesResponseMessage* msg;

    msg = new CIMEnumerateInstanceNamesResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setInstanceNames(instanceNames);
    return msg;
}

CIMEnumerateInstancesResponseMessage*
    CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMInstance> namedInstances;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMEnumerateInstancesResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMInstance namedInstance;

                while (XmlReader::getNamedInstanceElement(
                           parser, namedInstance))
                {
                    namedInstances.append(namedInstance);
                }

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMEnumerateInstancesResponseMessage* msg;

    msg = new CIMEnumerateInstancesResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setInstances(namedInstances);
    return msg;
}

CIMDeleteInstanceResponseMessage*
    CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMDeleteInstanceResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMDeleteInstanceResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMGetPropertyResponseMessage*
    CIMOperationResponseDecoder::_decodeGetPropertyResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    CIMValue cimValue(CIMTYPE_STRING, false);

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMGetPropertyResponseMessage(
                messageId,
                cimException,
                QueueIdStack(),
                CIMValue());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                if (!XmlReader::getPropertyValue(parser, cimValue))
                {
                    // No value given; just return a null String value
                }

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
        else
        {
            // No value given; just return a null String value
        }
    }

    return new CIMGetPropertyResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        cimValue);
}

CIMSetPropertyResponseMessage*
    CIMOperationResponseDecoder::_decodeSetPropertyResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMSetPropertyResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMSetPropertyResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMSetQualifierResponseMessage*
    CIMOperationResponseDecoder::_decodeSetQualifierResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMSetQualifierResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMSetQualifierResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMGetQualifierResponseMessage*
    CIMOperationResponseDecoder::_decodeGetQualifierResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (isEmptyImethodresponseTag)
    {
        MessageLoaderParms mlParms(""Common.XmlReader.EXPECTED_OPEN"",
            ""Expected open of $0 element"", ""IMETHODRESPONSE"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
    else if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMGetQualifierResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            CIMQualifierDecl());
    }
    else if (XmlReader::testStartTag(parser, entry, ""IRETURNVALUE""))
    {
        CIMQualifierDecl qualifierDecl;
        XmlReader::getQualifierDeclElement(parser, qualifierDecl);

        XmlReader::expectEndTag(parser, ""IRETURNVALUE"");

        return new CIMGetQualifierResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            qualifierDecl);
    }
    else
    {
        MessageLoaderParms mlParms(
            ""Client.CIMOperationResponseDecoder.""
                ""EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT"",
            ""expected ERROR or IRETURNVALUE element"");
        throw XmlValidationError(parser.getLine(), mlParms);
    }
}

CIMEnumerateQualifiersResponseMessage*
    CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMQualifierDecl> qualifierDecls;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMEnumerateQualifiersResponseMessage(
                messageId,
                cimException,
                QueueIdStack(),
                Array<CIMQualifierDecl>());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMQualifierDecl qualifierDecl;

                while (XmlReader::getQualifierDeclElement(
                           parser, qualifierDecl))
                {
                    qualifierDecls.append(qualifierDecl);
                }

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMEnumerateQualifiersResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        qualifierDecls);
}

CIMDeleteQualifierResponseMessage*
    CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMDeleteQualifierResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    return new CIMDeleteQualifierResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMReferenceNamesResponseMessage*
    CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> objectPaths;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMReferenceNamesResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMObjectPath objectPath;

                while (XmlReader::getObjectPathElement(parser, objectPath))
                    objectPaths.append(objectPath);

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMReferenceNamesResponseMessage* msg;

    msg = new CIMReferenceNamesResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setInstanceNames(objectPaths);

    return msg;
}

CIMReferencesResponseMessage*
    CIMOperationResponseDecoder::_decodeReferencesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObject> objectWithPathArray;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMReferencesResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMObject objectWithPath;

                while (XmlReader::getValueObjectWithPathElement(
                           parser, objectWithPath))
                {
                    objectWithPathArray.append(objectWithPath);
                }

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMReferencesResponseMessage *msg;

    msg = new CIMReferencesResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setObjects(objectWithPathArray);

    return msg;
}

CIMAssociatorNamesResponseMessage*
    CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> objectPaths;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMAssociatorNamesResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMObjectPath objectPath;

                while (XmlReader::getObjectPathElement(parser, objectPath))
                    objectPaths.append(objectPath);

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMAssociatorNamesResponseMessage* msg;

    msg = new CIMAssociatorNamesResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setInstanceNames(objectPaths);

    return msg;
}

CIMAssociatorsResponseMessage*
    CIMOperationResponseDecoder::_decodeAssociatorsResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObject> objectWithPathArray;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMAssociatorsResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                CIMObject objectWithPath;

                while (XmlReader::getValueObjectWithPathElement(
                           parser, objectWithPath))
                {
                    objectWithPathArray.append(objectWithPath);
                }

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMAssociatorsResponseMessage* msg;

    msg = new CIMAssociatorsResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setObjects(objectWithPathArray);

    return msg;
}

CIMExecQueryResponseMessage*
    CIMOperationResponseDecoder::_decodeExecQueryResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObject> objectWithPathArray;

    if (!isEmptyImethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMExecQueryResponseMessage(
                messageId,
                cimException,
                QueueIdStack());
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::getObjectArray(parser, objectWithPathArray);

                XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
            }
        }
    }

    CIMExecQueryResponseMessage* msg;

    msg = new CIMExecQueryResponseMessage(
        messageId,
        cimException,
        QueueIdStack());

    msg->getResponseData().setObjects(objectWithPathArray);

    return msg;
}

CIMInvokeMethodResponseMessage*
    CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
        XmlParser& parser,
        const String& messageId,
        const String& methodName,
        Boolean isEmptyMethodresponseTag)
{
    CIMException cimException;

    CIMParamValue paramValue;
    Array<CIMParamValue> outParameters;
    CIMValue returnValue;

    if (!isEmptyMethodresponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            return new CIMInvokeMethodResponseMessage(
                messageId,
                cimException,
                QueueIdStack(),
                returnValue,
                outParameters,
                methodName);
        }

        Boolean isReturnValue = false;
        Boolean isParamValue = false;
        Boolean gotReturnValue = false;

        while ((isReturnValue =
                    XmlReader::getReturnValueElement(parser, returnValue)) ||
               (isParamValue =
                    XmlReader::getParamValueElement(parser, paramValue)))
        {
            if (isReturnValue)
            {
                if (gotReturnValue)
                {
                    MessageLoaderParms mlParms(
                        ""Client.CIMOperationResponseDecoder.""
                            ""EXPECTED_RETURNVALUE_ELEMENT"",
                        ""unexpected RETURNVALUE element"");
                    throw XmlValidationError(parser.getLine(), mlParms);
                }
                gotReturnValue = true;
            }
            else    // isParamValue == true
            {
                outParameters.append(paramValue);
            }

            isReturnValue = false;
            isParamValue = false;
        }
    }

    return new CIMInvokeMethodResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        returnValue,
        outParameters,
        methodName);
}

// EXP_PULL_BEGIN
/**************************************************************************
**
**   Common Functions to support the decode of Pull Operation Responses
**
***************************************************************************/

/*
    Decode the instancePath portion of all of the open an pull instancepaths
    operations.  This function is common to all of the pull decode operations.
*/

// KS_EXP_TBD - Can we combine what we do here with the function in
// enumerateinstancenames that uses getInstanceNameElement????
void _decodeInstancePathElements(
    XmlParser& parser,
    Array<CIMObjectPath>& instancePaths)
{
    XmlEntry entry;
    if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
    {
        if (entry.type != XmlEntry::EMPTY_TAG)
        {
            CIMObjectPath instancePath;

            while (XmlReader::getInstancePathElement(parser, instancePath))
            {
                instancePaths.append(instancePath);
            }
            XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
        }
    }
}

/*
    decode returned instancesWithPathElement into an array
    of instances. This function is common to all of the Pull decoder
    operations.
*/
void _decodeGetInstancesWithPathElement(
    XmlParser& parser,
    Array<CIMInstance>& namedInstances)
{
    XmlEntry entry;
    if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
    {
        if (entry.type != XmlEntry::EMPTY_TAG)
        {
            CIMInstance namedInstance;

            /// KS_TBD _QUESTION. Diff of this getNameInstances Function
            while (XmlReader::getInstanceWithPathElement(
                       parser, namedInstance))
            {
                namedInstances.append(namedInstance);
            }

            XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
        }
    }
}

/*
    Decode returned instances Element into an array
    of instances. This function is only for pullInstances.
*/
void _decodeGetInstancesElement(
    XmlParser& parser,
    Array<CIMInstance>& instances)
{
    XmlEntry entry;
    if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
    {
        if (entry.type != XmlEntry::EMPTY_TAG)
        {
            CIMInstance instance;

            while (XmlReader::getInstanceElement(parser, instance))
            {
                instances.append(instance);
            }

            XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
        }
    }
}

/*  Common Function for Open, Pull Parm Value processing.
    Parse the output parameters from the  responses that
    have two parameters (endOfSequence and enumerationContext). These
    parameters are common across all of the Open* operations and the
    pull operations.
    This function returns the parsed values of these parameters or, if
    there is an error, generates an exception.
*/
void _decodeOpenResponseParamValues(XmlParser& parser,
       Boolean& endOfSequence,
       String& enumerationContext)
{
    Boolean duplicateParameter = false;
    Boolean gotEndOfSequence = false;
    Boolean gotEnumerationContext = false;

    Boolean emptyTag;
    for (const char* name;
         XmlReader::getParamValueTag(parser, name, emptyTag); )
    {
        if (System::strcasecmp(name, ""EndOfSequence"") == 0)
        {
            XmlReader::rejectNullParamValue(parser, emptyTag, name);
            XmlReader::getBooleanValueElement(parser, endOfSequence, true);
            duplicateParameter = gotEndOfSequence;
            gotEndOfSequence = true;
        }

        else if (System::strcasecmp(name, ""EnumerationContext"") == 0)
        {
            XmlReader::getStringValueElement(parser, enumerationContext,
                false);
            duplicateParameter = gotEnumerationContext;
            gotEnumerationContext = true;
        }
        else
        {
            // Ignore this as an extra tag
        }
        if (!emptyTag)
        {
            XmlReader::expectEndTag(parser, ""PARAMVALUE"");
        }
        // Stop on the first duplicate found
        if (duplicateParameter)
        {
            throw PEGASUS_CIM_EXCEPTION(
                CIM_ERR_INVALID_PARAMETER,
                    ""Duplicate EndOfSequence or EnumerationContext received"");
        }
    }

    // KS_TODO -Should the error be INVALID_PARAMETER or XmlValidation since
    // it is really MISSING but this is response so we have generally
    // used XmlValidationError.
    if (!gotEndOfSequence)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""EndOfSequence is a Required Parameter"");
    }

    // EnumerationContext is required parameter
    if (!gotEnumerationContext)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""EnumerationContext is a Required Parameter"");
    }
    // EnumerationContext must have value if not endOfSequence
    if ((!endOfSequence) && (enumerationContext.size() == 0))
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Valid EnumerationContext is a Required Parameter"");
    }
}

/******************************************************************************
**
** Open and Pull Operation Response Decoders
**
******************************************************************************/
CIMOpenEnumerateInstancesResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenEnumerateInstancesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    //XmlEntry entry;
    CIMException cimException;
    Array<CIMInstance> namedInstances;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenEnumerateInstancesResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }
    // EXP_PULL should error out if response empty because either
    // enumerationContext or endOfSequence is required. Create
    // missing Parameter error here.
    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    _decodeGetInstancesWithPathElement(parser, namedInstances);

    // Get the OUT parameters (endOfSequence and enumerationContext)
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenEnumerateInstancesResponseMessage* msg;

    msg = new CIMOpenEnumerateInstancesResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstances(namedInstances);
    return msg;
}

CIMOpenEnumerateInstancePathsResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenEnumerateInstancePathsResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> instancePaths;

    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenEnumerateInstancePathsResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");

    }

    _decodeInstancePathElements(parser, instancePaths);

    // Get the OUT parameters (endOfSequence and enumerationContext)
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenEnumerateInstancePathsResponseMessage* msg;

    msg = new CIMOpenEnumerateInstancePathsResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstanceNames(instancePaths);
    return msg;
}


CIMOpenReferenceInstancesResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenReferenceInstancesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;

    Array<CIMInstance> namedInstances;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenReferenceInstancesResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    _decodeGetInstancesWithPathElement(parser, namedInstances);

    // Get the OUT parameters (endOfSequence and enumerationContext)
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenReferenceInstancesResponseMessage* msg;

    msg = new CIMOpenReferenceInstancesResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    // set response data type to Instances.  The default for this
    // message is OBJECTS since that is what we use in the server.
    msg->getResponseData().setDataType(CIMResponseData::RESP_INSTANCES);
    msg->getResponseData().setInstances(namedInstances);

    return msg;
}

CIMOpenReferenceInstancePathsResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenReferenceInstancePathsResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> instancePaths;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenReferenceInstancePathsResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }
    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    _decodeInstancePathElements(parser, instancePaths);

    // Get the OUT parameters (endOfSequence and enumerationContext)
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenReferenceInstancePathsResponseMessage* msg;

    msg = new CIMOpenReferenceInstancePathsResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstanceNames(instancePaths);

    return msg;
}

CIMOpenAssociatorInstancesResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenAssociatorInstancesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMInstance> namedInstances;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenAssociatorInstancesResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    _decodeGetInstancesWithPathElement(parser, namedInstances);

    // Get the OUT parameters (endOfSequence and enumerationContext)
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenAssociatorInstancesResponseMessage* msg;

    msg = new CIMOpenAssociatorInstancesResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setDataType(CIMResponseData::RESP_INSTANCES);
    msg->getResponseData().setInstances(namedInstances);

    return msg;
}

CIMOpenAssociatorInstancePathsResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenAssociatorInstancePathsResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> instancePaths;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenAssociatorInstancePathsResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    if (XmlReader::testStartTagOrEmptyTag(parser, entry, ""IRETURNVALUE""))
    {
        if (entry.type != XmlEntry::EMPTY_TAG)
        {
            CIMObjectPath instancePath;

            while (XmlReader::getInstancePathElement(parser, instancePath))
                instancePaths.append(instancePath);
            XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
        }
    }

    // Get the OUT parameters (endOfSequence and enumerationContext)
    //
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenAssociatorInstancePathsResponseMessage* msg;

    msg = new CIMOpenAssociatorInstancePathsResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstanceNames(instancePaths);

    return msg;
}

CIMOpenQueryInstancesResponseMessage*
    CIMOperationResponseDecoder::_decodeOpenQueryInstancesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    CIMException cimException;
    Array<CIMInstance> instances;
    CIMClass queryResultClass;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMOpenQueryInstancesResponseMessage(
            messageId,
            cimException,
            CIMClass(),
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }
    // EXP_PULL error out if response empty because either
    // enumerationContext or endOfSequence is required. Create
    // missing Parameter error here.
    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    _decodeGetInstancesElement(parser, instances);

    // Get the OUT parameters (endOfSequence and enumerationContext)
    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMOpenQueryInstancesResponseMessage* msg =
        new CIMOpenQueryInstancesResponseMessage(
            messageId,
            cimException,
            queryResultClass,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);

    msg->getResponseData().setInstances(instances);
    return msg;
}

CIMPullInstancesWithPathResponseMessage*
    CIMOperationResponseDecoder::_decodePullInstancesWithPathResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMInstance> namedInstances;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMPullInstancesWithPathResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }
    _decodeGetInstancesWithPathElement(parser, namedInstances);

    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMPullInstancesWithPathResponseMessage* msg;

    msg = new CIMPullInstancesWithPathResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstances(namedInstances);
    return msg;
}

CIMPullInstancePathsResponseMessage*
    CIMOperationResponseDecoder::_decodePullInstancePathsResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> instancePaths;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    //Boolean duplicateParameter = false;
    //Boolean gotEndOfSequence = false;
    //Boolean gotEnumerationContext = false;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMPullInstancePathsResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    _decodeInstancePathElements(parser, instancePaths);

    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMPullInstancePathsResponseMessage* msg;

    msg = new CIMPullInstancePathsResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstanceNames(instancePaths);
    return msg;
}

CIMPullInstancesResponseMessage*
    CIMOperationResponseDecoder::_decodePullInstancesResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMInstance> instances;
    Boolean endOfSequence = true;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMPullInstancesResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            endOfSequence,
            enumerationContext);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }
    _decodeGetInstancesElement(parser, instances);

    _decodeOpenResponseParamValues(parser, endOfSequence, enumerationContext);

    CIMPullInstancesResponseMessage* msg;

    msg = new CIMPullInstancesResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        endOfSequence,
        enumerationContext);

    msg->getResponseData().setInstances(instances);
    return msg;
}

CIMCloseEnumerationResponseMessage*
    CIMOperationResponseDecoder::_decodeCloseEnumerationResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Array<CIMObjectPath> instanceNames;
    String enumerationContext = String::EMPTY;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMCloseEnumerationResponseMessage(
            messageId,
            cimException,
            QueueIdStack());
    }

    return new CIMCloseEnumerationResponseMessage(
        messageId,
        cimException,
        QueueIdStack());
}

CIMEnumerationCountResponseMessage*
    CIMOperationResponseDecoder::_decodeEnumerationCountResponse(
        XmlParser& parser,
        const String& messageId,
        Boolean isEmptyImethodresponseTag)
{
    XmlEntry entry;
    CIMException cimException;
    Uint64Arg count;

    Boolean duplicateParameter = false;
    Boolean gotCount = false;

    if (XmlReader::getErrorElement(parser, cimException))
    {
        return new CIMEnumerationCountResponseMessage(
            messageId,
            cimException,
            QueueIdStack(),
            0);
    }

    if (isEmptyImethodresponseTag)
    {
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
            ""Return Parameters endOfSequence""
                ""and/or enumerationContext required."");
    }

    // Extract the parameter count from the message

    Boolean emptyTag;
    for (const char* name;
         XmlReader::getIReturnValueTag(parser, name, emptyTag); )
    {
        if (System::strcasecmp(name, ""Count"") == 0)
        {
            XmlReader::getUint64ValueElement(parser, count, true);
            //duplicateParameter = gotCount;
            gotCount = true;
        }

        else
        {
            /// EXP_PULL_TBD
            // We probably simply want to ignore this as an extra tag
        }
        if (!emptyTag)
        {
            XmlReader::expectEndTag(parser, ""IRETURNVALUE"");
        }

        if (duplicateParameter)
        {
            throw PEGASUS_CIM_EXCEPTION(
                CIM_ERR_INVALID_PARAMETER, String::EMPTY);
        }

        // EXP_PULL_TBD add test here for the required parameters
        // NOT sure from the spec if the parameter is required or not.

        if (!gotCount)
        {
            throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
                                        ""Return value missing"");
        }
    }
    return new CIMEnumerationCountResponseMessage(
        messageId,
        cimException,
        QueueIdStack(),
        count);
}

//EXP_PULL_END

PEGASUS_NAMESPACE_END
",16146,True,3065.3506177627414,median